Change StackElementFilter into an interface and add a Builder for common filters

src/main/java/io/avaje/logback/encoder/Eval.java

@@ -0,0 +1,78 @@
+package io.avaje.logback.encoder;
+
+/**
+ * Helper to evaluate expressions like {@code "${my.property}"}, {@code "${MY_PROPERTY:someDefaultValue}"} etc.
+ */
+final class Eval {
+
+ /**
+ * Return the default component value using environment variables.
+ * <p>
+ * For K8s this derives the component name from the HOSTNAME.
+ */
+ static String defaultComponent() {
+ String component = System.getenv("COMPONENT");
+ if (component != null) {
+ return component;
+ }
+ if (System.getenv("KUBERNETES_PORT") != null) {
+ // in k8s we can default off the hostname
+ return k8sComponent(System.getenv("HOSTNAME"));
+ }
+ return null;
+ }
+
+ static String k8sComponent(String hostname) {
+ if (hostname == null) {
+ return null;
+ }
+ int p0 = hostname.lastIndexOf('-');
+ if (p0 > 1) {
+ int p1 = hostname.lastIndexOf('-', p0 - 1);
+ if (p1 > 0) {
+ return hostname.substring(0, p1);
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Evaluate the expression and otherwise return the original value.
+ * <p>
+ * Expressions are in the form {@code ${key:defaultValue}}
+ * <p>
+ * Examples:
+ * <pre>{@code
+ *
+ * ${APP_ENV:localDev}
+ * ${system.name:unknown}
+ * ${MY_COMPONENT:myDefaultValue}
+ *
+ * }</pre>
+ */
+ static String eval(String value) {
+ if (value == null || !value.startsWith("${") || !value.endsWith("}")) {
+ return value;
+ }
+ String raw = value.substring(2, value.length() - 1);
+ String[] split = raw.split(":", 2);
+ String key = split[0];
+ String val = System.getProperty(key);
+ if (val != null) {
+ return val;
+ }
+ val = System.getenv(key);
+ if (val != null) {
+ return val;
+ }
+ val = System.getProperty(toSystemPropertyKey(key));
+ if (val != null) {
+ return val;
+ }
+ return split.length == 2 ? split[1] : value;
+ }
+
+ static String toSystemPropertyKey(String key) {
+ return key.replace('_', '.').toLowerCase();
+ }
+}

src/main/java/io/avaje/logback/encoder/FilterBuilder.java

@@ -0,0 +1,167 @@
+package io.avaje.logback.encoder;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+final class FilterBuilder implements StackElementFilter.Builder {
+
+ private final List<StackElementFilter> filters = new ArrayList<>();
+
+ @Override
+ public StackElementFilter.Builder generated() {
+ filters.add(new Generated());
+ return this;
+ }
+
+ @Override
+ public StackElementFilter.Builder reflectiveInvocation() {
+ filters.add(new ReflectiveInvocation());
+ return this;
+ }
+
+ @Override
+ public StackElementFilter.Builder jdkInternals() {
+ filters.add(new JDKInternals());
+ return this;
+ }
+
+ @Override
+ public StackElementFilter.Builder spring() {
+ filters.add(new SpringFilter());
+ return this;
+ }
+
+ @Override
+ public StackElementFilter.Builder byPattern(List<Pattern> excludes) {
+ if (excludes != null && !excludes.isEmpty()) {
+ filters.add(new PatternFilter(excludes));
+ }
+ return this;
+ }
+
+ @Override
+ public StackElementFilter.Builder allFilters() {
+ generated();
+ reflectiveInvocation();
+ jdkInternals();
+ spring();
+ return this;
+ }
+
+ @Override
+ public StackElementFilter build() {
+ if (filters.isEmpty()) {
+ return StackElementFilter.any();
+ }
+ return new Group(filters.toArray(new StackElementFilter[0]));
+ }
+
+ private static final class Generated implements StackElementFilter {
+
+ @Override
+ public boolean accept(StackTraceElement element) {
+ String className = element.getClassName();
+ return !className.contains("$$FastClassByCGLIB$$")
+ && !className.contains("$$EnhancerBySpringCGLIB$$");
+ }
+ }
+
+ private static final class ReflectiveInvocation implements StackElementFilter {
+
+ @Override
+ public boolean accept(StackTraceElement element) {
+ String methodName = element.getMethodName();
+ if (methodName.equals("invoke")) {
+ String className = element.getClassName();
+ return !className.startsWith("sun.reflect.")
+ && !className.startsWith("java.lang.reflect.")
+ && !className.startsWith("net.sf.cglib.proxy.MethodProxy");
+ }
+ return true;
+ }
+ }
+
+ private static final class JDKInternals implements StackElementFilter {
+
+ @Override
+ public boolean accept(StackTraceElement element) {
+ String className = element.getClassName();
+ return !className.startsWith("com.sun.")
+ && !className.startsWith("sun.net.");
+ }
+ }
+
+ private static final class SpringFilter implements StackElementFilter {
+
+ private static final String[] MATCHES = {
+ "org.springframework.cglib.",
+ "org.springframework.transaction.",
+ "org.springframework.validation.",
+ "org.springframework.app.",
+ "org.springframework.aop.",
+ "org.springframework.ws.",
+ "org.springframework.web.",
+ "org.springframework.transaction"
+ };
+
+ @Override
+ public boolean accept(StackTraceElement element) {
+ String className = element.getClassName();
+ if (className.startsWith("org.springframework")) {
+ for (String match : MATCHES) {
+ if (className.startsWith(match)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ if (className.startsWith("org.apache")) {
+ return !className.startsWith("org.apache.tomcat.")
+ && !className.startsWith("org.apache.catalina.")
+ && !className.startsWith("org.apache.coyote.");
+ }
+ return true;
+ }
+ }
+
+ private static final class PatternFilter implements StackElementFilter {
+
+ private final Pattern[] excludes;
+
+ PatternFilter(final List<Pattern> excludes) {
+ this.excludes = excludes.toArray(new Pattern[0]);
+ }
+
+ @Override
+ public boolean accept(StackTraceElement element) {
+ final String classNameAndMethod = element.getClassName() + "." + element.getMethodName();
+ for (final Pattern exclusionPattern : excludes) {
+ if (exclusionPattern.matcher(classNameAndMethod).find()) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ private static final class Group implements StackElementFilter {
+
+ private final StackElementFilter[] filters;
+
+ public Group(StackElementFilter[] filters) {
+ this.filters = filters;
+ }
+
+ @Override
+ public boolean accept(StackTraceElement element) {
+ for (StackElementFilter filter : filters) {
+ if (!filter.accept(element)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+}

src/main/java/io/avaje/logback/encoder/JsonEncoder.java

@@ -9,6 +9,8 @@
 
 import ch.qos.logback.classic.pattern.ThrowableHandlingConverter;
 import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.classic.spi.IThrowableProxy;
+import ch.qos.logback.classic.spi.ThrowableProxy;
 import ch.qos.logback.core.encoder.EncoderBase;
 import io.avaje.json.PropertyNames;
 import io.avaje.json.simple.SimpleMapper;
@@ -20,6 +22,7 @@ public final class JsonEncoder extends EncoderBase<ILoggingEvent> {
  private final JsonStream json;
  private final Map<String, String> customFieldsMap = new HashMap<>();
  private final PropertyNames properties;
+ private final StackHasher stackHasher;
  private ThrowableHandlingConverter throwableConverter = new ShortenedThrowableConverter();
 
  private DateTimeFormatter formatter;
@@ -29,12 +32,14 @@ public final class JsonEncoder extends EncoderBase<ILoggingEvent> {
  private int fieldExtra;
  private String component;
  private String environment;
+ private boolean includeStackHash = true;
 
  public JsonEncoder() {
  this.json = JsonStream.builder().build();
- this.properties = json.properties("component", "env", "timestamp", "level", "logger", "message", "thread", "stacktrace");
- this.component = System.getenv("COMPONENT");
+ this.properties = json.properties("component", "env", "timestamp", "level", "logger", "message", "thread", "stackhash", "stacktrace");
+ this.component = Eval.defaultComponent();
  this.environment = System.getenv("ENVIRONMENT");
+ this.stackHasher = new StackHasher(StackElementFilter.builder().allFilters().build());
  }
 
  @Override
@@ -96,7 +101,15 @@ public byte[] encode(ILoggingEvent event) {
  writer.name(6);
  writer.value(threadName);
  if (!stackTraceBody.isEmpty()) {
- writer.name(7);
+ if (includeStackHash) {
+ IThrowableProxy throwableProxy = event.getThrowableProxy();
+ if (throwableProxy instanceof ThrowableProxy) {
+ String hash = stackHasher.hexHash(((ThrowableProxy) throwableProxy).getThrowable());
+ writer.name(7);
+ writer.value(hash);
+ }
+ }
+ writer.name(8);
  writer.value(stackTraceBody);
  }
  customFieldsMap.forEach((k, v) -> {
@@ -113,12 +126,16 @@ public byte[] encode(ILoggingEvent event) {
  return outputStream.toByteArray();
  }
 
+ public void setIncludeStackHash(boolean includeStackHash) {
+ this.includeStackHash = includeStackHash;
+ }
+
  public void setComponent(String component) {
- this.component = component;
+ this.component = Eval.eval(component);
  }
 
  public void setEnvironment(String environment) {
- this.environment = environment;
+ this.environment = Eval.eval(environment);
  }
 
  public void setThrowableConverter(ThrowableHandlingConverter throwableConverter) {
@@ -130,7 +147,12 @@ public void setCustomFields(String customFields) {
  return;
  }
  var mapper = SimpleMapper.builder().jsonStream(json).build();
- mapper.map().fromJson(customFields).forEach((k, v) -> customFieldsMap.put(k, mapper.toJson(v)));
+ mapper.map().fromJson(customFields).forEach((key, value) -> {
+ if (value instanceof String) {
+ value = Eval.eval((String) value);
+ }
+ customFieldsMap.put(key, mapper.toJson(value));
+ });
  }
 
  public void setTimestampPattern(String pattern) {