/** * Wrap the given primary logger with a composite logger that delegates to * it or to the fallback logger "org.springframework.web.HttpLogging", * if the primary is not enabled. * @param primaryLogger the primary logger to use * @return the resulting composite logger */ public static Log forLog(Log primaryLogger) { return LogDelegateFactory.getCompositeLog(primaryLogger, fallbackLogger); }
/** * Constructor with list of loggers. For optimal performance, the constructor * checks and remembers which logger is on for each log category. * @param loggers the loggers to use */ public CompositeLog(List<Log> loggers) { this.fatalLogger = initLogger(loggers, Log::isFatalEnabled); this.errorLogger = initLogger(loggers, Log::isErrorEnabled); this.warnLogger = initLogger(loggers, Log::isWarnEnabled); this.infoLogger = initLogger(loggers, Log::isInfoEnabled); this.debugLogger = initLogger(loggers, Log::isDebugEnabled); this.traceLogger = initLogger(loggers, Log::isTraceEnabled); }
/** * Create a composite logger that delegates to a primary or falls back on a * secondary logger if logging for the primary logger is not enabled. * <p>This may be used for fallback logging from lower level packages that * logically should log together with some higher level package but the two * don't happen to share a suitable parent package (e.g. logging for the web * and lower level http and codec packages). For such cases the primary, * class-based logger can be wrapped with a shared fallback logger. * @param primaryLogger primary logger to try first * @param secondaryLogger secondary logger * @param tertiaryLoggers optionally, more fallback loggers * @return the resulting logger to use */ public static Log getCompositeLog(Log primaryLogger, Log secondaryLogger, Log... tertiaryLoggers) { List<Log> loggers = new ArrayList<>(2 + tertiaryLoggers.length); loggers.add(primaryLogger); loggers.add(secondaryLogger); Collections.addAll(loggers, tertiaryLoggers); return new CompositeLog(loggers); }
private void logFormData(MultiValueMap<String, String> form, Map<String, Object> hints) { LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Writing " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(form, !traceOn) : "form fields " + form.keySet() + " (content masked)")); }
private void logResponse(ClientHttpResponse response, String logPrefix) { LogFormatUtils.traceDebug(logger, traceOn -> { int code = response.getRawStatusCode(); HttpStatus status = HttpStatus.resolve(code); return logPrefix + "Response " + (status != null ? status : code) + (traceOn ? ", headers=" + formatHeaders(response.getHeaders()) : ""); }); }
private void logFormData(MultiValueMap<String, String> formData, Map<String, Object> hints) { LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Read " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(formData, !traceOn) : "form fields " + formData.keySet() + " (content masked)")); }
private void logRequest(ClientRequest request) { LogFormatUtils.traceDebug(logger, traceOn -> request.logPrefix() + "HTTP " + request.method() + " " + request.url() + (traceOn ? ", headers=" + formatHeaders(request.headers()) : "") ); }
/** * Wrap the given primary logger with a composite logger that delegates to * either the primary or to the shared fallback logger * "org.springframework.web.HttpLogging", if the primary is not enabled. * @param primaryLogger the primary logger to use * @return the resulting composite logger */ public static Log forLog(Log primaryLogger) { return LogDelegateFactory.getCompositeLog(primaryLogger, fallbackLogger); }
/** * Constructor with list of loggers. For optimal performance, the constructor * checks and remembers which logger is on for each log category. * @param loggers the loggers to use */ public CompositeLog(List<Log> loggers) { this.fatalLogger = initLogger(loggers, Log::isFatalEnabled); this.errorLogger = initLogger(loggers, Log::isErrorEnabled); this.warnLogger = initLogger(loggers, Log::isWarnEnabled); this.infoLogger = initLogger(loggers, Log::isInfoEnabled); this.debugLogger = initLogger(loggers, Log::isDebugEnabled); this.traceLogger = initLogger(loggers, Log::isTraceEnabled); }
@Override protected String decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Charset charset = getCharset(mimeType); CharBuffer charBuffer = charset.decode(dataBuffer.asByteBuffer()); DataBufferUtils.release(dataBuffer); String value = charBuffer.toString(); LogFormatUtils.traceDebug(logger, traceOn -> { String formatted = LogFormatUtils.formatValue(value, !traceOn); return Hints.getLogPrefix(hints) + "Decoded " + formatted; }); return value; }
private void logResponse(ServerWebExchange exchange) { LogFormatUtils.traceDebug(logger, traceOn -> { HttpStatus status = exchange.getResponse().getStatusCode(); return exchange.getLogPrefix() + "Completed " + (status != null ? status : "200 OK") + (traceOn ? ", headers=" + formatHeaders(exchange.getResponse().getHeaders()) : ""); }); }
/** * Wrap the given primary logger with a composite logger that delegates to * it or to the fallback logger "org.springframework.web.HttpLogging", * if the primary is not enabled. * @param primaryLogger the primary logger to use * @return the resulting composite logger */ public static Log forLog(Log primaryLogger) { return LogDelegateFactory.getCompositeLog(primaryLogger, fallbackLogger); }
private void logFormData(MultiValueMap<String, String> formData, Map<String, Object> hints) { LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Read " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(formData, !traceOn) : "form fields " + formData.keySet() + " (content masked)")); }
/** * Cleanup the Spring MultipartFiles created during multipart parsing, * potentially holding temporary data on disk. * <p>Deletes the underlying Commons FileItem instances. * @param multipartFiles a Collection of MultipartFile instances * @see org.apache.commons.fileupload.FileItem#delete() */ protected void cleanupFileItems(MultiValueMap<String, MultipartFile> multipartFiles) { for (List<MultipartFile> files : multipartFiles.values()) { for (MultipartFile file : files) { if (file instanceof CommonsMultipartFile) { CommonsMultipartFile cmf = (CommonsMultipartFile) file; cmf.getFileItem().delete(); LogFormatUtils.traceDebug(logger, traceOn -> "Cleaning up part '" + cmf.getName() + "', filename '" + cmf.getOriginalFilename() + "'" + (traceOn ? ", stored " + cmf.getStorageDescription() : "")); } } } }
private void logFormData(MultiValueMap<String, String> form, Map<String, Object> hints) { LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Writing " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(form, !traceOn) : "form fields " + form.keySet() + " (content masked)")); }
private void logResponse(ServerWebExchange exchange) { LogFormatUtils.traceDebug(logger, traceOn -> { HttpStatus status = exchange.getResponse().getStatusCode(); return exchange.getLogPrefix() + "Completed " + (status != null ? status : "200 OK") + (traceOn ? ", headers=" + formatHeaders(exchange.getResponse().getHeaders()) : ""); }); }
@Override public Mono<MultiValueMap<String, Part>> readMono(ResolvableType elementType, ReactiveHttpInputMessage inputMessage, Map<String, Object> hints) { Map<String, Object> allHints = Hints.merge(hints, Hints.SUPPRESS_LOGGING_HINT, true); return this.partReader.read(elementType, inputMessage, allHints) .collectMultimap(Part::name) .doOnNext(map -> { LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Parsed " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(map, !traceOn) : "parts " + map.keySet() + " (content masked)")); }) .map(this::toMultiValueMap); }
@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) { if (this.forwardedHeaderTransformer != null) { request = this.forwardedHeaderTransformer.apply(request); } ServerWebExchange exchange = createExchange(request, response); LogFormatUtils.traceDebug(logger, traceOn -> exchange.getLogPrefix() + formatRequest(exchange.getRequest()) + (traceOn ? ", headers=" + formatHeaders(exchange.getRequest().getHeaders()) : "")); return getDelegate().handle(exchange) .doOnSuccess(aVoid -> logResponse(exchange)) .onErrorResume(ex -> handleUnresolvedError(exchange, ex)) .then(Mono.defer(response::setComplete)); }
@Override public Flux<Part> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints) { return Flux.create(new SynchronossPartGenerator(message, this.bufferFactory, this.streamStorageFactory)) .doOnNext(part -> { if (!Hints.isLoggingSuppressed(hints)) { LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Parsed " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(part, !traceOn) : "parts '" + part.name() + "' (content masked)")); } }); }
@Override public Flux<Object> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Flux<XMLEvent> xmlEventFlux = this.xmlEventDecoder.decode( inputStream, ResolvableType.forClass(XMLEvent.class), mimeType, hints); Class<?> outputClass = elementType.toClass(); QName typeName = toQName(outputClass); Flux<List<XMLEvent>> splitEvents = split(xmlEventFlux, typeName); return splitEvents.map(events -> { Object value = unmarshal(events, outputClass); LogFormatUtils.traceDebug(logger, traceOn -> { String formatted = LogFormatUtils.formatValue(value, !traceOn); return Hints.getLogPrefix(hints) + "Decoded [" + formatted + "]"; }); return value; }); }