GitHub-Spring
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Polish nullability annotations 

See gh-46926
pull/47162/head
Moritz Halbritter 3 months ago
parent
5ca904c17a
commit
634933b3e5
12 changed files with 103 additions and 63 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      core/spring-boot/src/main/java/org/springframework/boot/json/JsonValueWriter.java
  2. 47
      core/spring-boot/src/main/java/org/springframework/boot/json/JsonWriter.java
  3. 13
      core/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/GraylogExtendedLogFormatStructuredLogFormatter.java
  4. 7
      core/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/LogstashStructuredLogFormatter.java
  5. 5
      core/spring-boot/src/main/java/org/springframework/boot/logging/logback/ElasticCommonSchemaStructuredLogFormatter.java
  6. 9
      core/spring-boot/src/main/java/org/springframework/boot/logging/logback/GraylogExtendedLogFormatStructuredLogFormatter.java
  7. 7
      core/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogstashStructuredLogFormatter.java
  8. 42
      core/spring-boot/src/main/java/org/springframework/boot/logging/structured/ContextPairs.java
  9. 1
      core/spring-boot/src/main/java/org/springframework/boot/logging/structured/ElasticCommonSchemaProperties.java
  10. 2
      core/spring-boot/src/main/java/org/springframework/boot/logging/structured/GraylogExtendedLogFormatProperties.java
  11. 19
      core/spring-boot/src/main/java/org/springframework/boot/util/LambdaSafe.java
  12. 7
      smoke-test/spring-boot-smoke-test-structured-logging/src/main/java/smoketest/structuredlogging/SampleJsonMembersCustomizer.java

7
core/spring-boot/src/main/java/org/springframework/boot/json/JsonValueWriter.java
Unescape View File

@ -149,7 +149,7 @@ class JsonValueWriter {
} }
} }
private <V> boolean canWriteAsArray(Iterable<?> iterable) { private boolean canWriteAsArray(Iterable<?> iterable) {
return !(iterable instanceof Path); return !(iterable instanceof Path);
} }
@ -349,7 +349,8 @@ class JsonValueWriter {
// Lambda isn't detected with the correct nullability // Lambda isn't detected with the correct nullability
@SuppressWarnings({ "unchecked", "NullAway" }) @SuppressWarnings({ "unchecked", "NullAway" })
private <V> @Nullable V processValue(@Nullable V value, ValueProcessor<?> valueProcessor) { private <V> @Nullable V processValue(@Nullable V value, ValueProcessor<?> valueProcessor) {
return (V) LambdaSafe.callback(ValueProcessor.class, valueProcessor, this.path, new Object[] { value }) return (V) LambdaSafe
.callback(ValueProcessor.class, valueProcessor, this.path, new @Nullable Object[] { value })
.invokeAnd((call) -> call.processValue(this.path, value)) .invokeAnd((call) -> call.processValue(this.path, value))
.get(value); .get(value);
} }
@ -389,7 +390,7 @@ class JsonValueWriter {
private int index; private int index;
private Set<String> names = new HashSet<>(); private final Set<String> names = new HashSet<>();
private ActiveSeries(Series series) { private ActiveSeries(Series series) {
this.series = series; this.series = series;

47
core/spring-boot/src/main/java/org/springframework/boot/json/JsonWriter.java
Unescape View File

@ -29,6 +29,7 @@ import java.util.function.Predicate;
import java.util.function.Supplier; import java.util.function.Supplier;
import java.util.function.UnaryOperator; import java.util.function.UnaryOperator;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable; import org.jspecify.annotations.Nullable;
import org.springframework.boot.json.JsonValueWriter.Series; import org.springframework.boot.json.JsonValueWriter.Series;
@ -118,9 +119,9 @@ public interface JsonWriter<T> {
* Return a new {@link JsonWriter} instance that appends the given suffix after the * Return a new {@link JsonWriter} instance that appends the given suffix after the
* JSON has been written. * JSON has been written.
* @param suffix the suffix to write, if any * @param suffix the suffix to write, if any
* @return a new {@link JsonWriter} instance that appends a suffixafter the JSON * @return a new {@link JsonWriter} instance that appends a suffix after the JSON
*/ */
default JsonWriter<T> withSuffix(String suffix) { default JsonWriter<T> withSuffix(@Nullable String suffix) {
if (!StringUtils.hasLength(suffix)) { if (!StringUtils.hasLength(suffix)) {
return this; return this;
} }
@ -221,7 +222,7 @@ public interface JsonWriter<T> {
* @param supplier a supplier of the value * @param supplier a supplier of the value
* @return the added {@link Member} which may be configured further * @return the added {@link Member} which may be configured further
*/ */
public <V> Member<V> add(String name, Supplier<V> supplier) { public <V> Member<V> add(String name, Supplier<@Nullable V> supplier) {
Assert.notNull(supplier, "'supplier' must not be null"); Assert.notNull(supplier, "'supplier' must not be null");
return add(name, (instance) -> supplier.get()); return add(name, (instance) -> supplier.get());
} }
@ -233,7 +234,7 @@ public interface JsonWriter<T> {
* @param extractor {@link Extractor} to extract the value * @param extractor {@link Extractor} to extract the value
* @return the added {@link Member} which may be configured further * @return the added {@link Member} which may be configured further
*/ */
public <V> Member<V> add(String name, Extractor<T, ? extends @Nullable V> extractor) { public <V> Member<V> add(String name, Extractor<T, V> extractor) {
Assert.notNull(name, "'name' must not be null"); Assert.notNull(name, "'name' must not be null");
Assert.notNull(extractor, "'extractor' must not be null"); Assert.notNull(extractor, "'extractor' must not be null");
return addMember(name, extractor); return addMember(name, extractor);
@ -268,7 +269,7 @@ public interface JsonWriter<T> {
* @param value the member value * @param value the member value
* @return the added {@link Member} which may be configured further * @return the added {@link Member} which may be configured further
*/ */
public <V> Member<V> from(V value) { public <V> Member<V> from(@Nullable V value) {
return from((instance) -> value); return from((instance) -> value);
} }
@ -279,7 +280,7 @@ public interface JsonWriter<T> {
* @param supplier a supplier of the value * @param supplier a supplier of the value
* @return the added {@link Member} which may be configured further * @return the added {@link Member} which may be configured further
*/ */
public <V> Member<V> from(Supplier<V> supplier) { public <V> Member<V> from(Supplier<@Nullable V> supplier) {
Assert.notNull(supplier, "'supplier' must not be null"); Assert.notNull(supplier, "'supplier' must not be null");
return from((instance) -> supplier.get()); return from((instance) -> supplier.get());
} }
@ -323,7 +324,7 @@ public interface JsonWriter<T> {
this.jsonProcessors.valueProcessors().add(valueProcessor); this.jsonProcessors.valueProcessors().add(valueProcessor);
} }
private <V> Member<V> addMember(@Nullable String name, Extractor<T, ? extends @Nullable V> extractor) { private <V> Member<V> addMember(@Nullable String name, Extractor<T, V> extractor) {
Member<V> member = new Member<>(this.members.size(), name, ValueExtractor.of(extractor)); Member<V> member = new Member<>(this.members.size(), name, ValueExtractor.of(extractor));
this.members.add(member); this.members.add(member);
return member; return member;
@ -396,7 +397,7 @@ public interface JsonWriter<T> {
* @param extractor an function used to extract the value to test * @param extractor an function used to extract the value to test
* @return a {@link Member} which may be configured further * @return a {@link Member} which may be configured further
*/ */
public Member<T> whenNotNull(Function<T, ?> extractor) { public Member<T> whenNotNull(Function<@Nullable T, ?> extractor) {
Assert.notNull(extractor, "'extractor' must not be null"); Assert.notNull(extractor, "'extractor' must not be null");
return when((instance) -> Objects.nonNull(extractor.apply(instance))); return when((instance) -> Objects.nonNull(extractor.apply(instance)));
} }
@ -417,7 +418,8 @@ public interface JsonWriter<T> {
* @return a {@link Member} which may be configured further * @return a {@link Member} which may be configured further
*/ */
public Member<T> whenNotEmpty() { public Member<T> whenNotEmpty() {
return whenNot(ObjectUtils::isEmpty); Predicate<@Nullable T> isEmpty = ObjectUtils::isEmpty;
return whenNot(isEmpty);
} }
/** /**
@ -425,7 +427,7 @@ public interface JsonWriter<T> {
* @param predicate the predicate to test * @param predicate the predicate to test
* @return a {@link Member} which may be configured further * @return a {@link Member} which may be configured further
*/ */
public Member<T> whenNot(Predicate<T> predicate) { public Member<T> whenNot(Predicate<@Nullable T> predicate) {
Assert.notNull(predicate, "'predicate' must not be null"); Assert.notNull(predicate, "'predicate' must not be null");
return when(predicate.negate()); return when(predicate.negate());
} }
@ -448,7 +450,7 @@ public interface JsonWriter<T> {
* @return a {@link Member} which may be configured further * @return a {@link Member} which may be configured further
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public <R> Member<R> as(Extractor<T, ? extends @Nullable R> extractor) { public <R> Member<R> as(Extractor<T, R> extractor) {
Assert.notNull(extractor, "'adapter' must not be null"); Assert.notNull(extractor, "'adapter' must not be null");
Member<R> result = (Member<R>) this; Member<R> result = (Member<R>) this;
result.valueExtractor = this.valueExtractor.as(extractor::extract); result.valueExtractor = this.valueExtractor.as(extractor::extract);
@ -688,7 +690,7 @@ public interface JsonWriter<T> {
* @param <T> the member type * @param <T> the member type
*/ */
@FunctionalInterface @FunctionalInterface
interface ValueExtractor<T> { interface ValueExtractor<T extends @Nullable Object> {
/** /**
* Represents a skipped value. * Represents a skipped value.
@ -722,7 +724,7 @@ public interface JsonWriter<T> {
* @param extractor the extractor to use * @param extractor the extractor to use
* @return a new {@link ValueExtractor} * @return a new {@link ValueExtractor}
*/ */
default <R> ValueExtractor<R> as(Extractor<T, ? extends @Nullable R> extractor) { default <R> ValueExtractor<R> as(Extractor<T, R> extractor) {
return (instance) -> apply(extract(instance), extractor); return (instance) -> apply(extract(instance), extractor);
} }
@ -946,7 +948,7 @@ public interface JsonWriter<T> {
* @param existingName the existing and possibly already processed name. * @param existingName the existing and possibly already processed name.
* @return the new name * @return the new name
*/ */
String processName(MemberPath path, String existingName); @Nullable String processName(MemberPath path, String existingName);
/** /**
* Factory method to create a new {@link NameProcessor} for the given operation. * Factory method to create a new {@link NameProcessor} for the given operation.
@ -969,7 +971,7 @@ public interface JsonWriter<T> {
* @param <T> the value type * @param <T> the value type
*/ */
@FunctionalInterface @FunctionalInterface
interface ValueProcessor<T> { interface ValueProcessor<T extends @Nullable Object> {
/** /**
* Process the value at the given path. * Process the value at the given path.
@ -977,7 +979,7 @@ public interface JsonWriter<T> {
* @param value the value being written (may be {@code null}) * @param value the value being written (may be {@code null})
* @return the processed value * @return the processed value
*/ */
T processValue(MemberPath path, T value); @Nullable T processValue(MemberPath path, @Nullable T value);
/** /**
* Return a new processor from this one that only applied to members with the * Return a new processor from this one that only applied to members with the
@ -1018,7 +1020,8 @@ public interface JsonWriter<T> {
* type. * type.
*/ */
default ValueProcessor<T> whenInstanceOf(Class<?> type) { default ValueProcessor<T> whenInstanceOf(Class<?> type) {
return when(type::isInstance); Predicate<@Nullable T> isInstance = type::isInstance;
return when(isInstance);
} }
/** /**
@ -1028,7 +1031,7 @@ public interface JsonWriter<T> {
* @return a new {@link ValueProcessor} that only applies when the predicate * @return a new {@link ValueProcessor} that only applies when the predicate
* matches * matches
*/ */
default ValueProcessor<T> when(Predicate<T> predicate) { default ValueProcessor<T> when(Predicate<@Nullable T> predicate) {
return (name, value) -> (predicate.test(value)) ? processValue(name, value) : value; return (name, value) -> (predicate.test(value)) ? processValue(name, value) : value;
} }
@ -1040,7 +1043,7 @@ public interface JsonWriter<T> {
* @param action the action to apply * @param action the action to apply
* @return a new {@link ValueProcessor} instance * @return a new {@link ValueProcessor} instance
*/ */
static <T> ValueProcessor<T> of(Class<? extends T> type, UnaryOperator<T> action) { static <T> ValueProcessor<T> of(Class<? extends T> type, UnaryOperator<@Nullable T> action) {
return of(action).whenInstanceOf(type); return of(action).whenInstanceOf(type);
} }
@ -1051,7 +1054,7 @@ public interface JsonWriter<T> {
* @param action the action to apply * @param action the action to apply
* @return a new {@link ValueProcessor} instance * @return a new {@link ValueProcessor} instance
*/ */
static <T> ValueProcessor<T> of(UnaryOperator<T> action) { static <T> ValueProcessor<T> of(UnaryOperator<@Nullable T> action) {
Assert.notNull(action, "'action' must not be null"); Assert.notNull(action, "'action' must not be null");
return (name, value) -> action.apply(value); return (name, value) -> action.apply(value);
} }
@ -1065,14 +1068,14 @@ public interface JsonWriter<T> {
* @param <R> the result type * @param <R> the result type
*/ */
@FunctionalInterface @FunctionalInterface
interface Extractor<T, R> { interface Extractor<T extends @Nullable Object, R extends @Nullable Object> {
/** /**
* Extract from the given value. * Extract from the given value.
* @param value the source value (never {@code null}) * @param value the source value (never {@code null})
* @return an extracted value or {@code null} * @return an extracted value or {@code null}
*/ */
@Nullable R extract(T value); @Nullable R extract(@NonNull T value);
} }

13
core/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/GraylogExtendedLogFormatStructuredLogFormatter.java
Unescape View File

@ -18,7 +18,8 @@ package org.springframework.boot.logging.log4j2;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.util.Set; import java.util.Set;
import java.util.function.BinaryOperator; import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
@ -37,6 +38,7 @@ import org.springframework.boot.json.WritableJson;
import org.springframework.boot.logging.StackTracePrinter; import org.springframework.boot.logging.StackTracePrinter;
import org.springframework.boot.logging.structured.CommonStructuredLogFormat; import org.springframework.boot.logging.structured.CommonStructuredLogFormat;
import org.springframework.boot.logging.structured.ContextPairs; import org.springframework.boot.logging.structured.ContextPairs;
import org.springframework.boot.logging.structured.ContextPairs.Joiner;
import org.springframework.boot.logging.structured.GraylogExtendedLogFormatProperties; import org.springframework.boot.logging.structured.GraylogExtendedLogFormatProperties;
import org.springframework.boot.logging.structured.JsonWriterStructuredLogFormatter; import org.springframework.boot.logging.structured.JsonWriterStructuredLogFormatter;
import org.springframework.boot.logging.structured.StructuredLogFormatter; import org.springframework.boot.logging.structured.StructuredLogFormatter;
@ -91,12 +93,15 @@ class GraylogExtendedLogFormatStructuredLogFormatter extends JsonWriterStructure
members.add("_process_thread_name", LogEvent::getThreadName); members.add("_process_thread_name", LogEvent::getThreadName);
GraylogExtendedLogFormatProperties.get(environment).jsonMembers(members); GraylogExtendedLogFormatProperties.get(environment).jsonMembers(members);
members.add("_log_logger", LogEvent::getLoggerName); members.add("_log_logger", LogEvent::getLoggerName);
Predicate<@Nullable ReadOnlyStringMap> mapIsEmpty = (map) -> map == null || map.isEmpty();
members.from(LogEvent::getContextData) members.from(LogEvent::getContextData)
.whenNot(ReadOnlyStringMap::isEmpty) .whenNot(mapIsEmpty)
.usingPairs(contextPairs.flat(additionalFieldJoiner(), .usingPairs(contextPairs.flat(additionalFieldJoiner(),
GraylogExtendedLogFormatStructuredLogFormatter::addContextDataPairs)); GraylogExtendedLogFormatStructuredLogFormatter::addContextDataPairs));
Function<@Nullable LogEvent, @Nullable Object> getThrownProxy = (event) -> (event != null)
? event.getThrownProxy() : null;
members.add() members.add()
.whenNotNull(LogEvent::getThrownProxy) .whenNotNull(getThrownProxy)
.usingMembers((thrownProxyMembers) -> throwableMembers(thrownProxyMembers, extractor)); .usingMembers((thrownProxyMembers) -> throwableMembers(thrownProxyMembers, extractor));
} }
@ -140,7 +145,7 @@ class GraylogExtendedLogFormatStructuredLogFormatter extends JsonWriterStructure
contextPairs.add((contextData, pairs) -> contextData.forEach(pairs::accept)); contextPairs.add((contextData, pairs) -> contextData.forEach(pairs::accept));
} }
private static BinaryOperator<@Nullable String> additionalFieldJoiner() { private static Joiner additionalFieldJoiner() {
return (prefix, name) -> { return (prefix, name) -> {
name = prefix + name; name = prefix + name;
if (!FIELD_NAME_VALID_PATTERN.matcher(name).matches()) { if (!FIELD_NAME_VALID_PATTERN.matcher(name).matches()) {

7
core/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/LogstashStructuredLogFormatter.java
Unescape View File

@ -21,6 +21,7 @@ import java.time.ZoneId;
import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatter;
import java.util.Set; import java.util.Set;
import java.util.TreeSet; import java.util.TreeSet;
import java.util.function.Predicate;
import org.apache.logging.log4j.Level; import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.Marker; import org.apache.logging.log4j.Marker;
@ -61,13 +62,15 @@ class LogstashStructuredLogFormatter extends JsonWriterStructuredLogFormatter<Lo
members.add("thread_name", LogEvent::getThreadName); members.add("thread_name", LogEvent::getThreadName);
members.add("level", LogEvent::getLevel).as(Level::name); members.add("level", LogEvent::getLevel).as(Level::name);
members.add("level_value", LogEvent::getLevel).as(Level::intLevel); members.add("level_value", LogEvent::getLevel).as(Level::intLevel);
Predicate<@Nullable ReadOnlyStringMap> mapIsEmpty = (map) -> map == null || map.isEmpty();
members.from(LogEvent::getContextData) members.from(LogEvent::getContextData)
.whenNot(ReadOnlyStringMap::isEmpty) .whenNot(mapIsEmpty)
.usingPairs(contextPairs.flat("_", LogstashStructuredLogFormatter::addContextDataPairs)); .usingPairs(contextPairs.flat("_", LogstashStructuredLogFormatter::addContextDataPairs));
Predicate<@Nullable Set<String>> collectionIsEmpty = CollectionUtils::isEmpty;
members.add("tags", LogEvent::getMarker) members.add("tags", LogEvent::getMarker)
.whenNotNull() .whenNotNull()
.as(LogstashStructuredLogFormatter::getMarkers) .as(LogstashStructuredLogFormatter::getMarkers)
.whenNot(CollectionUtils::isEmpty); .whenNot(collectionIsEmpty);
members.add("stack_trace", LogEvent::getThrownProxy).whenNotNull().as(extractor::stackTrace); members.add("stack_trace", LogEvent::getThrownProxy).whenNotNull().as(extractor::stackTrace);
} }

5
core/spring-boot/src/main/java/org/springframework/boot/logging/logback/ElasticCommonSchemaStructuredLogFormatter.java
Unescape View File

@ -20,6 +20,7 @@ import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import java.util.TreeSet; import java.util.TreeSet;
import java.util.function.Function;
import ch.qos.logback.classic.pattern.ThrowableProxyConverter; import ch.qos.logback.classic.pattern.ThrowableProxyConverter;
import ch.qos.logback.classic.spi.ILoggingEvent; import ch.qos.logback.classic.spi.ILoggingEvent;
@ -77,7 +78,9 @@ class ElasticCommonSchemaStructuredLogFormatter extends JsonWriterStructuredLogF
pairs.addMapEntries(ILoggingEvent::getMDCPropertyMap); pairs.addMapEntries(ILoggingEvent::getMDCPropertyMap);
pairs.add(ILoggingEvent::getKeyValuePairs, keyValuePairExtractor); pairs.add(ILoggingEvent::getKeyValuePairs, keyValuePairExtractor);
})); }));
members.add().whenNotNull(ILoggingEvent::getThrowableProxy).usingMembers((throwableMembers) -> { Function<@Nullable ILoggingEvent, @Nullable Object> getThrowableProxy = (event) -> (event != null)
? event.getThrowableProxy() : null;
members.add().whenNotNull(getThrowableProxy).usingMembers((throwableMembers) -> {
throwableMembers.add("error").usingMembers((error) -> { throwableMembers.add("error").usingMembers((error) -> {
error.add("type", ILoggingEvent::getThrowableProxy).as(IThrowableProxy::getClassName); error.add("type", ILoggingEvent::getThrowableProxy).as(IThrowableProxy::getClassName);
error.add("message", ILoggingEvent::getThrowableProxy).as(IThrowableProxy::getMessage); error.add("message", ILoggingEvent::getThrowableProxy).as(IThrowableProxy::getMessage);

9
core/spring-boot/src/main/java/org/springframework/boot/logging/logback/GraylogExtendedLogFormatStructuredLogFormatter.java
Unescape View File

@ -18,7 +18,7 @@ package org.springframework.boot.logging.logback;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.util.Set; import java.util.Set;
import java.util.function.BinaryOperator; import java.util.function.Function;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import ch.qos.logback.classic.pattern.ThrowableProxyConverter; import ch.qos.logback.classic.pattern.ThrowableProxyConverter;
@ -37,6 +37,7 @@ import org.springframework.boot.json.WritableJson;
import org.springframework.boot.logging.StackTracePrinter; import org.springframework.boot.logging.StackTracePrinter;
import org.springframework.boot.logging.structured.CommonStructuredLogFormat; import org.springframework.boot.logging.structured.CommonStructuredLogFormat;
import org.springframework.boot.logging.structured.ContextPairs; import org.springframework.boot.logging.structured.ContextPairs;
import org.springframework.boot.logging.structured.ContextPairs.Joiner;
import org.springframework.boot.logging.structured.GraylogExtendedLogFormatProperties; import org.springframework.boot.logging.structured.GraylogExtendedLogFormatProperties;
import org.springframework.boot.logging.structured.JsonWriterStructuredLogFormatter; import org.springframework.boot.logging.structured.JsonWriterStructuredLogFormatter;
import org.springframework.boot.logging.structured.StructuredLogFormatter; import org.springframework.boot.logging.structured.StructuredLogFormatter;
@ -100,8 +101,10 @@ class GraylogExtendedLogFormatStructuredLogFormatter extends JsonWriterStructure
pairs.addMapEntries(ILoggingEvent::getMDCPropertyMap); pairs.addMapEntries(ILoggingEvent::getMDCPropertyMap);
pairs.add(ILoggingEvent::getKeyValuePairs, keyValuePairExtractor); pairs.add(ILoggingEvent::getKeyValuePairs, keyValuePairExtractor);
})); }));
Function<@Nullable ILoggingEvent, @Nullable Object> getThrowableProxy = (event) -> (event != null)
? event.getThrowableProxy() : null;
members.add() members.add()
.whenNotNull(ILoggingEvent::getThrowableProxy) .whenNotNull(getThrowableProxy)
.usingMembers((throwableMembers) -> throwableMembers(throwableMembers, extractor)); .usingMembers((throwableMembers) -> throwableMembers(throwableMembers, extractor));
} }
@ -128,7 +131,7 @@ class GraylogExtendedLogFormatStructuredLogFormatter extends JsonWriterStructure
members.add("_error_message", ILoggingEvent::getThrowableProxy).as(IThrowableProxy::getMessage); members.add("_error_message", ILoggingEvent::getThrowableProxy).as(IThrowableProxy::getMessage);
} }
private static BinaryOperator<@Nullable String> additionalFieldJoiner() { private static Joiner additionalFieldJoiner() {
return (prefix, name) -> { return (prefix, name) -> {
name = prefix + name; name = prefix + name;
if (!FIELD_NAME_VALID_PATTERN.matcher(name).matches()) { if (!FIELD_NAME_VALID_PATTERN.matcher(name).matches()) {

7
core/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogstashStructuredLogFormatter.java
Unescape View File

@ -24,6 +24,7 @@ import java.util.Iterator;
import java.util.LinkedHashSet; import java.util.LinkedHashSet;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import java.util.function.Function;
import ch.qos.logback.classic.Level; import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.pattern.ThrowableProxyConverter; import ch.qos.logback.classic.pattern.ThrowableProxyConverter;
@ -76,9 +77,9 @@ class LogstashStructuredLogFormatter extends JsonWriterStructuredLogFormatter<IL
.whenNotNull() .whenNotNull()
.as(LogstashStructuredLogFormatter::getMarkers) .as(LogstashStructuredLogFormatter::getMarkers)
.whenNotEmpty(); .whenNotEmpty();
members.add("stack_trace", (event) -> event) Function<@Nullable ILoggingEvent, @Nullable Object> getThrowableProxy = (event) -> (event != null)
.whenNotNull(ILoggingEvent::getThrowableProxy) ? event.getThrowableProxy() : null;
.as(extractor::stackTrace); members.add("stack_trace", (event) -> event).whenNotNull(getThrowableProxy).as(extractor::stackTrace);
} }
private static String asTimestamp(Instant instant) { private static String asTimestamp(Instant instant) {

42
core/spring-boot/src/main/java/org/springframework/boot/logging/structured/ContextPairs.java
Unescape View File

@ -21,10 +21,8 @@ import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.Function; import java.util.function.Function;
import java.util.stream.Collectors;
import org.jspecify.annotations.Nullable; import org.jspecify.annotations.Nullable;
@ -69,8 +67,7 @@ public class ContextPairs {
* @param pairs callback to add all the pairs * @param pairs callback to add all the pairs
* @return a {@link BiConsumer} for use with the {@link JsonWriter} * @return a {@link BiConsumer} for use with the {@link JsonWriter}
*/ */
public <T> BiConsumer<T, BiConsumer<String, Object>> flat(BinaryOperator<@Nullable String> joiner, public <T> BiConsumer<T, BiConsumer<String, Object>> flat(Joiner joiner, Consumer<Pairs<T>> pairs) {
Consumer<Pairs<T>> pairs) {
return (!this.include) ? none() : new Pairs<>(joiner, pairs)::flat; return (!this.include) ? none() : new Pairs<>(joiner, pairs)::flat;
} }
@ -89,7 +86,7 @@ public class ContextPairs {
}; };
} }
private BinaryOperator<@Nullable String> joinWith(String delimiter) { private Joiner joinWith(String delimiter) {
return (prefix, name) -> { return (prefix, name) -> {
StringBuilder joined = new StringBuilder(prefix.length() + delimiter.length() + name.length()); StringBuilder joined = new StringBuilder(prefix.length() + delimiter.length() + name.length());
joined.append(prefix); joined.append(prefix);
@ -101,6 +98,22 @@ public class ContextPairs {
}; };
} }
/**
* Joins a prefix and a name.
*/
@FunctionalInterface
public interface Joiner {
/**
* Joins the given prefix and name.
* @param prefix the prefix
* @param name the name
* @return the joined result or {@code null}
*/
@Nullable String join(String prefix, String name);
}
/** /**
* Callback used to add pairs. * Callback used to add pairs.
* *
@ -108,11 +121,11 @@ public class ContextPairs {
*/ */
public class Pairs<T> { public class Pairs<T> {
private final BinaryOperator<@Nullable String> joiner; private final Joiner joiner;
private final List<BiConsumer<T, BiConsumer<String, ?>>> addedPairs; private final List<BiConsumer<T, BiConsumer<String, ?>>> addedPairs;
Pairs(BinaryOperator<@Nullable String> joiner, Consumer<Pairs<T>> pairs) { Pairs(Joiner joiner, Consumer<Pairs<T>> pairs) {
this.joiner = joiner; this.joiner = joiner;
this.addedPairs = new ArrayList<>(); this.addedPairs = new ArrayList<>();
pairs.accept(this); pairs.accept(this);
@ -120,11 +133,11 @@ public class ContextPairs {
/** /**
* Add pairs from map entries. * Add pairs from map entries.
* @param <K> the map key type
* @param <V> the map value type * @param <V> the map value type
* @param extractor the extractor used to provide the map * @param extractor the extractor used to provide the map
*/ */
public <K, V> void addMapEntries(Function<T, Map<String, V>> extractor) { @SuppressWarnings("NullAway") // Doesn't detect lambda with correct nullability
public <V> void addMapEntries(Function<T, Map<String, V>> extractor) {
add(extractor.andThen(Map::entrySet), Map.Entry::getKey, Map.Entry::getValue); add(extractor.andThen(Map::entrySet), Map.Entry::getKey, Map.Entry::getValue);
} }
@ -133,9 +146,8 @@ public class ContextPairs {
* @param elementsExtractor the extractor used to provide the iterable * @param elementsExtractor the extractor used to provide the iterable
* @param pairExtractor the extractor used to provide the name and value * @param pairExtractor the extractor used to provide the name and value
* @param <E> the element type * @param <E> the element type
* @param <V> the value type
*/ */
public <E, V> void add(Function<T, Iterable<E>> elementsExtractor, PairExtractor<E> pairExtractor) { public <E> void add(Function<T, @Nullable Iterable<E>> elementsExtractor, PairExtractor<E> pairExtractor) {
add(elementsExtractor, pairExtractor::getName, pairExtractor::getValue); add(elementsExtractor, pairExtractor::getName, pairExtractor::getValue);
} }
@ -147,7 +159,7 @@ public class ContextPairs {
* @param nameExtractor the extractor used to provide the name * @param nameExtractor the extractor used to provide the name
* @param valueExtractor the extractor used to provide the value * @param valueExtractor the extractor used to provide the value
*/ */
public <E, V> void add(Function<T, Iterable<E>> elementsExtractor, Function<E, String> nameExtractor, public <E, V> void add(Function<T, @Nullable Iterable<E>> elementsExtractor, Function<E, String> nameExtractor,
Function<E, V> valueExtractor) { Function<E, V> valueExtractor) {
add((item, pairs) -> { add((item, pairs) -> {
Iterable<E> elements = elementsExtractor.apply(item); Iterable<E> elements = elementsExtractor.apply(item);
@ -186,7 +198,7 @@ public class ContextPairs {
for (int i = 0; i < nameParts.size() - 1; i++) { for (int i = 0; i < nameParts.size() - 1; i++) {
Object existing = destination.computeIfAbsent(nameParts.get(i), (key) -> new LinkedHashMap<>()); Object existing = destination.computeIfAbsent(nameParts.get(i), (key) -> new LinkedHashMap<>());
if (!(existing instanceof Map)) { if (!(existing instanceof Map)) {
String common = nameParts.subList(0, i + 1).stream().collect(Collectors.joining(".")); String common = String.join(".", nameParts.subList(0, i + 1));
throw new IllegalStateException( throw new IllegalStateException(
"Duplicate nested pairs added under '%s'".formatted(common)); "Duplicate nested pairs added under '%s'".formatted(common));
} }
@ -196,12 +208,12 @@ public class ContextPairs {
Assert.state(previous == null, () -> "Duplicate nested pairs added under '%s'".formatted(name)); Assert.state(previous == null, () -> "Duplicate nested pairs added under '%s'".formatted(name));
})); }));
}); });
result.forEach(pairs::accept); result.forEach(pairs);
} }
private <V> BiConsumer<String, V> joining(BiConsumer<String, V> pairs) { private <V> BiConsumer<String, V> joining(BiConsumer<String, V> pairs) {
return (name, value) -> { return (name, value) -> {
name = this.joiner.apply(ContextPairs.this.prefix, (name != null) ? name : ""); name = this.joiner.join(ContextPairs.this.prefix, (name != null) ? name : "");
if (StringUtils.hasLength(name)) { if (StringUtils.hasLength(name)) {
pairs.accept(name, value); pairs.accept(name, value);
} }

1
core/spring-boot/src/main/java/org/springframework/boot/logging/structured/ElasticCommonSchemaProperties.java
Unescape View File

@ -82,6 +82,7 @@ public record ElasticCommonSchemaProperties(Service service) {
static final Service NONE = new Service(null, null, null, null); static final Service NONE = new Service(null, null, null, null);
@SuppressWarnings("NullAway") // Doesn't detect lambda with correct nullability
void jsonMembers(Members<?> members) { void jsonMembers(Members<?> members) {
members.add("service").usingMembers((service) -> { members.add("service").usingMembers((service) -> {
service.add("name", this::name).whenHasLength(); service.add("name", this::name).whenHasLength();

2
core/spring-boot/src/main/java/org/springframework/boot/logging/structured/GraylogExtendedLogFormatProperties.java
Unescape View File

@ -58,6 +58,7 @@ public record GraylogExtendedLogFormatProperties(@Nullable String host, Service
* Add {@link JsonWriter} members for the service. * Add {@link JsonWriter} members for the service.
* @param members the members to add to * @param members the members to add to
*/ */
@SuppressWarnings("NullAway") // Doesn't detect lambda with correct nullability
public void jsonMembers(JsonWriter.Members<?> members) { public void jsonMembers(JsonWriter.Members<?> members) {
members.add("host", this::host).whenHasLength(); members.add("host", this::host).whenHasLength();
this.service.jsonMembers(members); this.service.jsonMembers(members);
@ -90,6 +91,7 @@ public record GraylogExtendedLogFormatProperties(@Nullable String host, Service
return new Service(version); return new Service(version);
} }
@SuppressWarnings("NullAway") // Doesn't detect lambda with correct nullability
void jsonMembers(JsonWriter.Members<?> members) { void jsonMembers(JsonWriter.Members<?> members) {
members.add("_service_version", this::version).whenHasLength(); members.add("_service_version", this::version).whenHasLength();
} }

19
core/spring-boot/src/main/java/org/springframework/boot/util/LambdaSafe.java
Unescape View File

@ -70,7 +70,7 @@ public final class LambdaSafe {
* @return a {@link Callback} instance that can be invoked. * @return a {@link Callback} instance that can be invoked.
*/ */
public static <C, A> Callback<C, A> callback(Class<C> callbackType, C callbackInstance, A argument, public static <C, A> Callback<C, A> callback(Class<C> callbackType, C callbackInstance, A argument,
Object @Nullable ... additionalArguments) { @Nullable Object @Nullable ... additionalArguments) {
Assert.notNull(callbackType, "'callbackType' must not be null"); Assert.notNull(callbackType, "'callbackType' must not be null");
Assert.notNull(callbackInstance, "'callbackInstance' must not be null"); Assert.notNull(callbackInstance, "'callbackInstance' must not be null");
return new Callback<>(callbackType, callbackInstance, argument, additionalArguments); return new Callback<>(callbackType, callbackInstance, argument, additionalArguments);
@ -108,13 +108,13 @@ public final class LambdaSafe {
private final A argument; private final A argument;
private final Object @Nullable [] additionalArguments; private final @Nullable Object @Nullable [] additionalArguments;
private Log logger; private Log logger;
private Filter<C, A> filter = new GenericTypeFilter<>(); private Filter<C, A> filter = new GenericTypeFilter<>();
LambdaSafeCallback(Class<C> callbackType, A argument, Object @Nullable [] additionalArguments) { LambdaSafeCallback(Class<C> callbackType, A argument, @Nullable Object @Nullable [] additionalArguments) {
this.callbackType = callbackType; this.callbackType = callbackType;
this.argument = argument; this.argument = argument;
this.additionalArguments = additionalArguments; this.additionalArguments = additionalArguments;
@ -175,11 +175,11 @@ public final class LambdaSafe {
} }
private boolean startsWithArgumentClassName(String message) { private boolean startsWithArgumentClassName(String message) {
Predicate<Object> startsWith = (argument) -> startsWithArgumentClassName(message, argument); Predicate<@Nullable Object> startsWith = (argument) -> startsWithArgumentClassName(message, argument);
return startsWith.test(this.argument) || additonalArgumentsStartsWith(startsWith); return startsWith.test(this.argument) || additionalArgumentsStartsWith(startsWith);
} }
private boolean additonalArgumentsStartsWith(Predicate<Object> startsWith) { private boolean additionalArgumentsStartsWith(Predicate<@Nullable Object> startsWith) {
if (this.additionalArguments == null) { if (this.additionalArguments == null) {
return false; return false;
} }
@ -243,7 +243,7 @@ public final class LambdaSafe {
private final C callbackInstance; private final C callbackInstance;
private Callback(Class<C> callbackType, C callbackInstance, A argument, private Callback(Class<C> callbackType, C callbackInstance, A argument,
Object @Nullable [] additionalArguments) { @Nullable Object @Nullable [] additionalArguments) {
super(callbackType, argument, additionalArguments); super(callbackType, argument, additionalArguments);
this.callbackInstance = callbackInstance; this.callbackInstance = callbackInstance;
} }
@ -343,7 +343,8 @@ public final class LambdaSafe {
* @param additionalArguments any additional arguments * @param additionalArguments any additional arguments
* @return if the callback matches and should be invoked * @return if the callback matches and should be invoked
*/ */
boolean match(Class<C> callbackType, C callbackInstance, A argument, Object @Nullable [] additionalArguments); boolean match(Class<C> callbackType, C callbackInstance, A argument,
@Nullable Object @Nullable [] additionalArguments);
/** /**
* Return a {@link Filter} that allows all callbacks to be invoked. * Return a {@link Filter} that allows all callbacks to be invoked.
@ -365,7 +366,7 @@ public final class LambdaSafe {
@Override @Override
public boolean match(Class<C> callbackType, C callbackInstance, A argument, public boolean match(Class<C> callbackType, C callbackInstance, A argument,
Object @Nullable [] additionalArguments) { @Nullable Object @Nullable [] additionalArguments) {
ResolvableType type = ResolvableType.forClass(callbackType, callbackInstance.getClass()); ResolvableType type = ResolvableType.forClass(callbackType, callbackInstance.getClass());
if (type.getGenerics().length != 1) { if (type.getGenerics().length != 1) {
return true; return true;

7
smoke-test/spring-boot-smoke-test-structured-logging/src/main/java/smoketest/structuredlogging/SampleJsonMembersCustomizer.java
Unescape View File

@ -16,6 +16,10 @@
package smoketest.structuredlogging; package smoketest.structuredlogging;
import java.util.function.UnaryOperator;
import org.jspecify.annotations.Nullable;
import org.springframework.boot.json.JsonWriter.Members; import org.springframework.boot.json.JsonWriter.Members;
import org.springframework.boot.json.JsonWriter.ValueProcessor; import org.springframework.boot.json.JsonWriter.ValueProcessor;
import org.springframework.boot.logging.structured.StructuredLoggingJsonMembersCustomizer; import org.springframework.boot.logging.structured.StructuredLoggingJsonMembersCustomizer;
@ -24,8 +28,9 @@ public class SampleJsonMembersCustomizer implements StructuredLoggingJsonMembers
@Override @Override
public void customize(Members<Object> members) { public void customize(Members<Object> members) {
UnaryOperator<@Nullable String> formatted = "!!%s!!"::formatted;
members.applyingValueProcessor( members.applyingValueProcessor(
ValueProcessor.of(String.class, "!!%s!!"::formatted).whenHasUnescapedPath("process.thread.name")); ValueProcessor.of(String.class, formatted).whenHasUnescapedPath("process.thread.name"));
} }
} }

Write Preview
Loading…
Cancel
Save