@Override public String getLogPrefix() { return this.delegate.getLogPrefix(); } }
@Override public Map<String, Object> hints() { hints.put(Hints.LOG_PREFIX_HINT, exchange.getLogPrefix()); return hints; } });
@Override public Map<String, Object> hints() { hints.put(Hints.LOG_PREFIX_HINT, exchange.getLogPrefix()); return hints; } });
@Override public String getLogPrefix() { return getDelegate().getLogPrefix(); }
@Override public Mono<HandlerFunction<T>> route(ServerRequest request) { if (this.predicate.test(request)) { if (logger.isTraceEnabled()) { String logPrefix = request.exchange().getLogPrefix(); logger.trace(logPrefix + String.format("Matched %s", this.predicate)); } return Mono.just(this.handlerFunction); } else { return Mono.empty(); } }
private Mono<Void> handleBadRequest(ServerWebExchange exchange, String reason) { if (logger.isDebugEnabled()) { logger.debug(exchange.getLogPrefix() + reason); } return Mono.error(new ServerWebInputException(reason)); }
private void logArgumentErrorIfNecessary( ServerWebExchange exchange, MethodParameter parameter, Throwable cause) { // Leave stack trace for later, if error is not handled.. String message = cause.getMessage(); if (!message.contains(parameter.getExecutable().toGenericString())) { if (logger.isDebugEnabled()) { logger.debug(exchange.getLogPrefix() + formatArgumentError(parameter, message)); } } }
@Override public Mono<Resource> transform(ServerWebExchange exchange, Resource resource, ResourceTransformerChain transformerChain) { Resource cachedResource = this.cache.get(resource, Resource.class); if (cachedResource != null) { logger.trace(exchange.getLogPrefix() + "Resource resolved from cache"); return Mono.just(cachedResource); } return transformerChain.transform(exchange, resource) .doOnNext(transformed -> this.cache.put(resource, transformed)); }
private Mono<String> resolveResourceUrl(ServerWebExchange exchange, PathContainer lookupPath) { return this.handlerMap.entrySet().stream() .filter(entry -> entry.getKey().matches(lookupPath)) .min((entry1, entry2) -> PathPattern.SPECIFICITY_COMPARATOR.compare(entry1.getKey(), entry2.getKey())) .map(entry -> { PathContainer path = entry.getKey().extractPathWithinPattern(lookupPath); int endIndex = lookupPath.elements().size() - path.elements().size(); PathContainer mapping = lookupPath.subPath(0, endIndex); ResourceWebHandler handler = entry.getValue(); List<ResourceResolver> resolvers = handler.getResourceResolvers(); ResourceResolverChain chain = new DefaultResourceResolverChain(resolvers); return chain.resolveUrlPath(path.value(), handler.getLocations()) .map(resolvedPath -> mapping.value() + resolvedPath); }) .orElseGet(() ->{ if (logger.isTraceEnabled()) { logger.trace(exchange.getLogPrefix() + "No match for \"" + lookupPath + "\""); } return Mono.empty(); }); }
@Override public <T> T body(BodyExtractor<T, ? super ServerHttpRequest> extractor, Map<String, Object> hints) { hints = Hints.merge(hints, Hints.LOG_PREFIX_HINT, exchange().getLogPrefix()); return bodyInternal(extractor, hints); }
@Override protected Mono<Resource> resolveResourceInternal(@Nullable ServerWebExchange exchange, String requestPath, List<? extends Resource> locations, ResourceResolverChain chain) { String key = computeKey(exchange, requestPath); Resource cachedResource = this.cache.get(key, Resource.class); if (cachedResource != null) { String logPrefix = exchange != null ? exchange.getLogPrefix() : ""; logger.trace(logPrefix + "Resource resolved from cache"); return Mono.just(cachedResource); } return chain.resolveResource(exchange, requestPath, locations) .doOnNext(resource -> this.cache.put(key, resource)); }
@Override public Mono<HandlerFunction<T>> route(ServerRequest serverRequest) { return this.predicate.nest(serverRequest) .map(nestedRequest -> { if (logger.isTraceEnabled()) { String logPrefix = serverRequest.exchange().getLogPrefix(); logger.trace(logPrefix + String.format("Matched nested %s", this.predicate)); } return this.routerFunction.route(nestedRequest) .doOnNext(match -> { if (nestedRequest != serverRequest) { serverRequest.attributes().clear(); serverRequest.attributes() .putAll(nestedRequest.attributes()); } }); } ).orElseGet(Mono::empty); }
@SuppressWarnings("unchecked") private <T> Mono<Void> write(T value, @Nullable MediaType contentType, ServerWebExchange exchange) { Publisher<T> input = Mono.justOrEmpty(value); ResolvableType elementType = ResolvableType.forClass(value.getClass()); return ((HttpMessageWriter<T>) this.writer).write( input, elementType, contentType, exchange.getResponse(), Hints.from(Hints.LOG_PREFIX_HINT, exchange.getLogPrefix())); }
@Override public <T> T body(BodyExtractor<T, ? super ServerHttpRequest> extractor) { return bodyInternal(extractor, Hints.from(Hints.LOG_PREFIX_HINT, exchange().getLogPrefix())); }
private HandshakeInfo createHandshakeInfo(ServerWebExchange exchange, ServerHttpRequest request, @Nullable String protocol, Map<String, Object> attributes) { URI uri = request.getURI(); // Copy request headers, as they might be pooled and recycled by // the server implementation once the handshake HTTP exchange is done. HttpHeaders headers = new HttpHeaders(); headers.addAll(request.getHeaders()); Mono<Principal> principal = exchange.getPrincipal(); String logPrefix = exchange.getLogPrefix(); InetSocketAddress remoteAddress = request.getRemoteAddress(); return new HandshakeInfo(uri, headers, principal, protocol, remoteAddress, attributes, logPrefix); }
private Flux<?> decodePartValues(Flux<Part> parts, MethodParameter elementType, BindingContext bindingContext, ServerWebExchange exchange, boolean isRequired) { return parts.flatMap(part -> { ServerHttpRequest partRequest = new PartServerHttpRequest(exchange.getRequest(), part); ServerWebExchange partExchange = exchange.mutate().request(partRequest).build(); if (logger.isDebugEnabled()) { logger.debug(exchange.getLogPrefix() + "Decoding part '" + part.name() + "'"); } return readBody(elementType, isRequired, bindingContext, partExchange); }); }
@Override public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) { HttpStatus status = resolveStatus(ex); if (status == null || !exchange.getResponse().setStatusCode(status)) { return Mono.error(ex); } // Mirrors AbstractHandlerExceptionResolver in spring-webmvc... String logPrefix = exchange.getLogPrefix(); if (this.warnLogger != null && this.warnLogger.isWarnEnabled()) { this.warnLogger.warn(logPrefix + formatError(ex, exchange.getRequest()), ex); } else if (logger.isDebugEnabled()) { logger.debug(logPrefix + formatError(ex, exchange.getRequest())); } return exchange.getResponse().setComplete(); }
@Override public Mono<Object> getHandler(ServerWebExchange exchange) { return getHandlerInternal(exchange).map(handler -> { if (logger.isDebugEnabled()) { logger.debug(exchange.getLogPrefix() + "Mapped to " + handler); } if (CorsUtils.isCorsRequest(exchange.getRequest())) { CorsConfiguration configA = this.corsConfigurationSource.getCorsConfiguration(exchange); CorsConfiguration configB = getCorsConfiguration(handler, exchange); CorsConfiguration config = (configA != null ? configA.combine(configB) : configB); if (!getCorsProcessor().process(config, exchange) || CorsUtils.isPreFlightRequest(exchange.getRequest())) { return REQUEST_HANDLED_HANDLER; } } return handler; }); }
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<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)); }