mirror of
https://github.com/2martens/tsw-timetable.git
synced 2026-10-17 07:57:55 +02:00
Changed to Kotlin
This commit is contained in:
@@ -1,9 +0,0 @@
|
||||
plugins {
|
||||
id 'twomartens.spring-boot-cloud'
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation libs.mapstruct.base
|
||||
annotationProcessor libs.mapstruct.processor
|
||||
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
plugins {
|
||||
id("twomartens.spring-boot-cloud")
|
||||
id("twomartens.kotlin")
|
||||
kotlin("kapt")
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation(libs.mapstruct.base)
|
||||
implementation(libs.bundles.spring.boot.security)
|
||||
implementation(libs.jaxb.impl)
|
||||
implementation(libs.jakarta.xml.binding)
|
||||
annotationProcessor(libs.mapstruct.processor)
|
||||
kapt(libs.mapstruct.processor)
|
||||
implementation(libs.spring.cloud.starter.config)
|
||||
// implementation(libs.spring.cloud.starter.bus.kafka)
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
package de.twomartens.template;
|
||||
|
||||
import io.swagger.v3.oas.models.OpenAPI;
|
||||
import io.swagger.v3.oas.models.info.Info;
|
||||
import org.springframework.beans.factory.annotation.Value;
|
||||
import org.springframework.boot.SpringApplication;
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||||
import org.springframework.boot.builder.SpringApplicationBuilder;
|
||||
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.scheduling.annotation.EnableScheduling;
|
||||
|
||||
@EnableScheduling
|
||||
@SpringBootApplication
|
||||
public class MainApplication extends SpringBootServletInitializer {
|
||||
|
||||
@Override
|
||||
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
|
||||
return builder.sources(MainApplication.class);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
SpringApplication.run(MainApplication.class, args);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public OpenAPI customOpenAPI(@Value("${openapi.description}") String apiDesciption,
|
||||
@Value("${openapi.version}") String apiVersion, @Value("${openapi.title}") String apiTitle) {
|
||||
return new OpenAPI()
|
||||
.info(new Info()
|
||||
.title(apiTitle)
|
||||
.version(apiVersion)
|
||||
.description(apiDesciption));
|
||||
}
|
||||
}
|
||||
-20
@@ -1,20 +0,0 @@
|
||||
package de.twomartens.template.configuration;
|
||||
|
||||
import de.twomartens.template.property.ServiceProperties;
|
||||
import java.time.Clock;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Configuration
|
||||
@RequiredArgsConstructor
|
||||
public class ClockConfiguration {
|
||||
|
||||
private final ServiceProperties serviceProperties;
|
||||
|
||||
@Bean
|
||||
public Clock clock() {
|
||||
return Clock.system(serviceProperties.getDefaultTimeZone());
|
||||
}
|
||||
|
||||
}
|
||||
-22
@@ -1,22 +0,0 @@
|
||||
package de.twomartens.template.configuration;
|
||||
|
||||
import de.twomartens.template.interceptor.HeaderInterceptorRest;
|
||||
import de.twomartens.template.interceptor.LoggingInterceptorRest;
|
||||
import java.time.Clock;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Configuration
|
||||
public class InterceptorConfiguration {
|
||||
|
||||
@Bean
|
||||
public LoggingInterceptorRest loggingInterceptorRest(Clock clock) {
|
||||
return new LoggingInterceptorRest(clock);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public HeaderInterceptorRest headerInterceptorRest() {
|
||||
return new HeaderInterceptorRest();
|
||||
}
|
||||
|
||||
}
|
||||
-18
@@ -1,18 +0,0 @@
|
||||
package de.twomartens.template.configuration;
|
||||
|
||||
import org.springdoc.core.models.GroupedOpenApi;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Configuration
|
||||
public class OpenApiConfiguration {
|
||||
|
||||
@Bean
|
||||
public GroupedOpenApi swaggerApi10() {
|
||||
return GroupedOpenApi.builder()
|
||||
.group("1.0")
|
||||
.pathsToMatch("/template/v1/**")
|
||||
.build();
|
||||
}
|
||||
|
||||
}
|
||||
-34
@@ -1,34 +0,0 @@
|
||||
package de.twomartens.template.configuration;
|
||||
|
||||
import de.twomartens.template.interceptor.HeaderInterceptorRest;
|
||||
import de.twomartens.template.interceptor.LoggingInterceptorRest;
|
||||
import de.twomartens.template.property.RestTemplateTimeoutProperties;
|
||||
import org.springframework.boot.web.client.RestTemplateBuilder;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
import org.springframework.web.client.RestTemplate;
|
||||
|
||||
@Configuration
|
||||
public class RestTemplateConfiguration {
|
||||
|
||||
@Bean
|
||||
public RestTemplate restTemplate(HeaderInterceptorRest headerInterceptorRest,
|
||||
LoggingInterceptorRest loggingInterceptor,
|
||||
RestTemplateTimeoutProperties restTemplateTimeoutProperties) {
|
||||
return new RestTemplateBuilder()
|
||||
.additionalInterceptors(headerInterceptorRest, loggingInterceptor)
|
||||
.setConnectTimeout(restTemplateTimeoutProperties.getConnectionRestTemplateTimeoutInMillis())
|
||||
.setReadTimeout(restTemplateTimeoutProperties.getReadTimeoutRestTemplateInMillis())
|
||||
.build();
|
||||
}
|
||||
|
||||
@Bean
|
||||
public RestTemplate restTemplateRestHealthIndicator(HeaderInterceptorRest headerInterceptorRest,
|
||||
RestTemplateTimeoutProperties restTemplateTimeoutProperties) {
|
||||
return new RestTemplateBuilder()
|
||||
.additionalInterceptors(headerInterceptorRest)
|
||||
.setConnectTimeout(restTemplateTimeoutProperties.getConnectionRestHealthIndicatorTimeoutInMillis())
|
||||
.setReadTimeout(restTemplateTimeoutProperties.getReadTimeoutRestHealthIndicatorInMillis())
|
||||
.build();
|
||||
}
|
||||
}
|
||||
-28
@@ -1,28 +0,0 @@
|
||||
package de.twomartens.template.configuration;
|
||||
|
||||
import de.twomartens.template.monitoring.statusprobe.CountBasedStatusProbe;
|
||||
import de.twomartens.template.monitoring.statusprobe.StatusProbe;
|
||||
import de.twomartens.template.monitoring.statusprobe.StatusProbeCriticality;
|
||||
import de.twomartens.template.monitoring.statusprobe.StatusProbeLogger;
|
||||
import java.time.Clock;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Configuration
|
||||
@RequiredArgsConstructor
|
||||
public class StatusProbeConfiguration {
|
||||
|
||||
private final Clock clock;
|
||||
|
||||
@Bean
|
||||
public StatusProbeLogger statusProbeLogger() {
|
||||
return new StatusProbeLogger(clock);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public StatusProbe testStatusProbe(StatusProbeLogger statusProbeLogger) {
|
||||
return new CountBasedStatusProbe(1,
|
||||
clock, StatusProbeCriticality.K1, "testStatusProbe", statusProbeLogger);
|
||||
}
|
||||
}
|
||||
-28
@@ -1,28 +0,0 @@
|
||||
package de.twomartens.template.configuration;
|
||||
|
||||
import de.twomartens.template.interceptor.HeaderInterceptorRest;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
import org.springframework.web.servlet.config.annotation.CorsRegistration;
|
||||
import org.springframework.web.servlet.config.annotation.CorsRegistry;
|
||||
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
|
||||
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
|
||||
|
||||
@Configuration
|
||||
@RequiredArgsConstructor
|
||||
public class WebConfiguration implements WebMvcConfigurer {
|
||||
|
||||
private final HeaderInterceptorRest headerInterceptorRest;
|
||||
|
||||
@Override
|
||||
public void addInterceptors(InterceptorRegistry registry) {
|
||||
registry.addInterceptor(headerInterceptorRest);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addCorsMappings(CorsRegistry registry) {
|
||||
CorsRegistration registration = registry.addMapping("/**");
|
||||
registration.allowedOrigins("*");
|
||||
}
|
||||
|
||||
}
|
||||
-37
@@ -1,37 +0,0 @@
|
||||
package de.twomartens.template.controller;
|
||||
|
||||
import de.twomartens.template.exception.HttpStatusException;
|
||||
import de.twomartens.template.model.dto.ErrorMessage;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.http.HttpStatus;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.ControllerAdvice;
|
||||
import org.springframework.web.bind.annotation.ExceptionHandler;
|
||||
import org.springframework.web.bind.annotation.RestController;
|
||||
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
|
||||
|
||||
@ControllerAdvice(annotations = RestController.class)
|
||||
@Slf4j
|
||||
public class ExceptionController extends ResponseEntityExceptionHandler {
|
||||
|
||||
@ExceptionHandler(HttpStatusException.class)
|
||||
public ResponseEntity<ErrorMessage> handleException(HttpStatusException e) {
|
||||
if (e.getCause() != null) {
|
||||
log.info(e.getCause().toString(), e.getCause());
|
||||
} else {
|
||||
log.info(e.toString());
|
||||
}
|
||||
return ResponseEntity.status(e.getStatus()).body(ErrorMessage.builder()
|
||||
.message(e.getMessage())
|
||||
.build());
|
||||
}
|
||||
|
||||
@ExceptionHandler(RuntimeException.class)
|
||||
public ResponseEntity<ErrorMessage> handleRuntimeException(RuntimeException e) {
|
||||
log.error("unexpected exception occurred", e);
|
||||
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ErrorMessage.builder()
|
||||
.message(e.getMessage())
|
||||
.build());
|
||||
}
|
||||
|
||||
}
|
||||
-95
@@ -1,95 +0,0 @@
|
||||
package de.twomartens.template.controller;
|
||||
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.InputStream;
|
||||
import java.net.InetAddress;
|
||||
import java.net.URL;
|
||||
import java.net.UnknownHostException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.jar.JarFile;
|
||||
import java.util.zip.ZipEntry;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.stereotype.Controller;
|
||||
import org.springframework.web.bind.annotation.ControllerAdvice;
|
||||
import org.springframework.web.bind.annotation.GetMapping;
|
||||
import org.springframework.web.bind.annotation.ModelAttribute;
|
||||
import org.springframework.web.bind.annotation.RequestHeader;
|
||||
import org.springframework.web.bind.annotation.RequestMapping;
|
||||
|
||||
/**
|
||||
* used to show version and title information on html pages
|
||||
*/
|
||||
@Slf4j
|
||||
@Controller
|
||||
@RequiredArgsConstructor
|
||||
@RequestMapping(value = "/vorlage")
|
||||
public class VersionHtmlController {
|
||||
|
||||
@GetMapping(path = "/html/version.html")
|
||||
public String version() {
|
||||
return "version";
|
||||
}
|
||||
|
||||
@ControllerAdvice
|
||||
public static class VersionControllerAdvice {
|
||||
|
||||
@ModelAttribute("version")
|
||||
public String getApplicationVersion() {
|
||||
return getTitle() + " " + getVersion();
|
||||
}
|
||||
|
||||
@ModelAttribute("footerString")
|
||||
public String getApplicationVersion(@RequestHeader("host") String hostName) {
|
||||
return getTitle() + " " + getVersion() + " - " + hostName;
|
||||
}
|
||||
|
||||
private String getTitle() {
|
||||
return Optional.ofNullable(VersionControllerAdvice.class.getPackage().getImplementationTitle())
|
||||
.filter(s -> !s.isBlank())
|
||||
.orElse("application");
|
||||
}
|
||||
|
||||
public String getVersion() {
|
||||
return Optional.ofNullable(VersionControllerAdvice.class.getPackage().getImplementationVersion())
|
||||
.filter(s -> !s.isBlank())
|
||||
.orElse("DEVELOPER");
|
||||
}
|
||||
|
||||
@ModelAttribute("hostname")
|
||||
public String getHostname() {
|
||||
try {
|
||||
return InetAddress.getLocalHost().getHostName();
|
||||
} catch (UnknownHostException e) {
|
||||
log.warn(e.toString(), e);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@ModelAttribute("manifest")
|
||||
private Collection<String> getManifest() {
|
||||
try {
|
||||
URL location = getClass().getProtectionDomain().getCodeSource().getLocation();
|
||||
String jarFileName = Paths.get(location.toURI()).toString();
|
||||
try (JarFile jarFile = new JarFile(jarFileName)) {
|
||||
ZipEntry entry = jarFile.getEntry(JarFile.MANIFEST_NAME);
|
||||
try (InputStream in = jarFile.getInputStream(entry)) {
|
||||
return new String(in.readAllBytes(), StandardCharsets.UTF_8).lines().toList();
|
||||
}
|
||||
}
|
||||
} catch (FileNotFoundException ignored) {
|
||||
// do nothing if manifest file is not available
|
||||
} catch (Exception e) {
|
||||
log.info(e.toString(), e);
|
||||
}
|
||||
return List.of(getTitle() + " " + getVersion());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
-59
@@ -1,59 +0,0 @@
|
||||
package de.twomartens.template.controller.v1;
|
||||
|
||||
import de.twomartens.template.mapper.v1.GreetingMapper;
|
||||
import de.twomartens.template.model.dto.v1.Greeting;
|
||||
import de.twomartens.template.service.GreetingService;
|
||||
import io.swagger.v3.oas.annotations.Hidden;
|
||||
import io.swagger.v3.oas.annotations.Operation;
|
||||
import io.swagger.v3.oas.annotations.responses.ApiResponse;
|
||||
import io.swagger.v3.oas.annotations.tags.Tag;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.mapstruct.factory.Mappers;
|
||||
import org.springframework.web.bind.annotation.GetMapping;
|
||||
import org.springframework.web.bind.annotation.PostMapping;
|
||||
import org.springframework.web.bind.annotation.RequestBody;
|
||||
import org.springframework.web.bind.annotation.RequestMapping;
|
||||
import org.springframework.web.bind.annotation.RequestParam;
|
||||
import org.springframework.web.bind.annotation.RestController;
|
||||
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequiredArgsConstructor
|
||||
@RequestMapping(value = "/template/v1")
|
||||
@Tag(name = "Greeting Example", description = "all requests relating to greetings")
|
||||
public class GreetingRestController {
|
||||
|
||||
private final GreetingMapper mapper = Mappers.getMapper(GreetingMapper.class);
|
||||
|
||||
private final GreetingService service;
|
||||
|
||||
@Operation(
|
||||
summary = "Returns a greeting message",
|
||||
responses = {@ApiResponse(
|
||||
responseCode = "200")
|
||||
}
|
||||
)
|
||||
@GetMapping("/greeting")
|
||||
public Greeting greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
|
||||
return mapper.map(service.createGreeting(name));
|
||||
}
|
||||
|
||||
@Operation(
|
||||
summary = "Posts a greeting message to db",
|
||||
responses = {@ApiResponse(
|
||||
responseCode = "200")
|
||||
}
|
||||
)
|
||||
@PostMapping("/greeting")
|
||||
public void postGreeting(@RequestBody Greeting greeting) {
|
||||
service.postGreeting(mapper.map(greeting));
|
||||
}
|
||||
|
||||
@Hidden
|
||||
@GetMapping("/healthCheck")
|
||||
public String checkHealth(@RequestParam(value = "message") String message) {
|
||||
return message;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package de.twomartens.template.exception;
|
||||
|
||||
import lombok.Getter;
|
||||
import org.springframework.http.HttpStatus;
|
||||
|
||||
@Getter
|
||||
public class HttpStatusException extends RuntimeException {
|
||||
|
||||
private final HttpStatus status;
|
||||
|
||||
public HttpStatusException(HttpStatus status, String message) {
|
||||
super(message);
|
||||
this.status = status;
|
||||
}
|
||||
|
||||
public HttpStatusException(HttpStatus status, String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
this.status = status;
|
||||
}
|
||||
}
|
||||
-82
@@ -1,82 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2017 the original author or authors.
|
||||
*
|
||||
* Licensed 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
|
||||
*
|
||||
* https://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 de.twomartens.template.interceptor;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import org.springframework.http.HttpHeaders;
|
||||
import org.springframework.http.HttpStatusCode;
|
||||
import org.springframework.http.client.ClientHttpResponse;
|
||||
import org.springframework.lang.Nullable;
|
||||
import org.springframework.util.StreamUtils;
|
||||
|
||||
/**
|
||||
* Simple implementation of {@link ClientHttpResponse} that reads the response's body into memory, thus allowing for
|
||||
* multiple invocations of {@link #getBody()}.
|
||||
*
|
||||
* @author Arjen Poutsma
|
||||
* @since 3.1
|
||||
*/
|
||||
public final class BufferingClientHttpResponseWrapper implements ClientHttpResponse {
|
||||
|
||||
private final ClientHttpResponse response;
|
||||
|
||||
@Nullable
|
||||
private byte[] body;
|
||||
|
||||
|
||||
public BufferingClientHttpResponseWrapper(ClientHttpResponse response) {
|
||||
this.response = response;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public HttpStatusCode getStatusCode() throws IOException {
|
||||
return this.response.getStatusCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public int getRawStatusCode() throws IOException {
|
||||
return this.response.getRawStatusCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getStatusText() throws IOException {
|
||||
return this.response.getStatusText();
|
||||
}
|
||||
|
||||
@Override
|
||||
public HttpHeaders getHeaders() {
|
||||
return this.response.getHeaders();
|
||||
}
|
||||
|
||||
@Override
|
||||
public InputStream getBody() throws IOException {
|
||||
if (this.body == null) {
|
||||
this.body = StreamUtils.copyToByteArray(this.response.getBody());
|
||||
}
|
||||
return new ByteArrayInputStream(this.body);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
this.response.close();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,87 +0,0 @@
|
||||
package de.twomartens.template.interceptor;
|
||||
|
||||
import java.io.Closeable;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
import org.slf4j.MDC;
|
||||
|
||||
public abstract class HeaderInterceptor {
|
||||
|
||||
public static final String LOGGER_TRACE_ID = "trace.id";
|
||||
public static final String LOGGER_REQTYPE_ID = "REQTYPE";
|
||||
|
||||
public static final String HEADER_FIELD_TRACE_ID = "X-TraceId";
|
||||
public static final String HEADER_FIELD_B3_TRACE_ID = "x-b3-traceid";
|
||||
public static final String HEADER_FIELD_TYPE_ID = "x-type";
|
||||
|
||||
public static final String REQ_TYPE_HEALTHCHECK = "HEALTH_CHECK";
|
||||
public static final String REQ_TYPE_INTEGRATION_TEST = "INTEGRATION_TEST";
|
||||
public static final String REQ_TYPE_SERVER_TEST = "SERVER_TEST";
|
||||
public static final String REQ_TYPE_WARMUP = "WARMUP";
|
||||
|
||||
public String getTraceId() {
|
||||
return Optional.ofNullable(MDC.get(LOGGER_TRACE_ID))
|
||||
.filter(s -> !s.isBlank())
|
||||
.orElse(createNewTraceId());
|
||||
}
|
||||
|
||||
public Optional<String> getRequestType() {
|
||||
return Optional.ofNullable(MDC.get(LOGGER_REQTYPE_ID))
|
||||
.filter(requestType -> !requestType.isBlank());
|
||||
}
|
||||
|
||||
public InterceptorCloseables setTraceId(String traceId) {
|
||||
return new InterceptorCloseables(MDC.putCloseable(LOGGER_TRACE_ID, traceId));
|
||||
}
|
||||
|
||||
public InterceptorCloseables mark(String requestType) {
|
||||
return new InterceptorCloseables(MDC.putCloseable(LOGGER_REQTYPE_ID, requestType));
|
||||
}
|
||||
|
||||
public InterceptorCloseables set(String traceId, String requestType) {
|
||||
return requestType != null
|
||||
? new InterceptorCloseables(setTraceId(traceId), mark(requestType))
|
||||
: setTraceId(traceId);
|
||||
}
|
||||
|
||||
public InterceptorCloseables markAsHealthCheck() {
|
||||
return new InterceptorCloseables(mark(REQ_TYPE_HEALTHCHECK), setTraceId(createNewTraceId()));
|
||||
}
|
||||
|
||||
public InterceptorCloseables markAsIntegrationTest() {
|
||||
return new InterceptorCloseables(mark(REQ_TYPE_INTEGRATION_TEST), setTraceId(createNewTraceId()));
|
||||
}
|
||||
|
||||
public InterceptorCloseables markAsServerTest() {
|
||||
return new InterceptorCloseables(mark(REQ_TYPE_SERVER_TEST), setTraceId(createNewTraceId()));
|
||||
}
|
||||
|
||||
public InterceptorCloseables markAsWarmup() {
|
||||
return new InterceptorCloseables(mark(REQ_TYPE_WARMUP), setTraceId(createNewTraceId()));
|
||||
}
|
||||
|
||||
private static String createNewTraceId() {
|
||||
return UUID.randomUUID().toString();
|
||||
}
|
||||
|
||||
public static class InterceptorCloseables implements Closeable {
|
||||
|
||||
private final Closeable[] closeables;
|
||||
|
||||
private InterceptorCloseables(Closeable... closeables) {
|
||||
this.closeables = closeables;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
for (Closeable closeable : closeables) {
|
||||
try {
|
||||
closeable.close();
|
||||
} catch (Exception ignored) {
|
||||
// do nothing
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
-68
@@ -1,68 +0,0 @@
|
||||
package de.twomartens.template.interceptor;
|
||||
|
||||
import jakarta.servlet.http.HttpServletRequest;
|
||||
import jakarta.servlet.http.HttpServletResponse;
|
||||
import java.io.IOException;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
import org.springframework.http.HttpRequest;
|
||||
import org.springframework.http.client.ClientHttpRequestExecution;
|
||||
import org.springframework.http.client.ClientHttpRequestInterceptor;
|
||||
import org.springframework.http.client.ClientHttpResponse;
|
||||
import org.springframework.lang.NonNull;
|
||||
import org.springframework.web.servlet.HandlerInterceptor;
|
||||
import org.springframework.web.servlet.ModelAndView;
|
||||
|
||||
public class HeaderInterceptorRest extends HeaderInterceptor
|
||||
implements HandlerInterceptor, ClientHttpRequestInterceptor {
|
||||
|
||||
public static final String CLASS_NAME = HeaderInterceptorRest.class.getName();
|
||||
|
||||
// ClientHttpRequestInterceptor
|
||||
@Override
|
||||
@NonNull
|
||||
public ClientHttpResponse intercept(HttpRequest request, @NonNull byte[] body,
|
||||
ClientHttpRequestExecution execution) throws IOException {
|
||||
request.getHeaders().add(HEADER_FIELD_TRACE_ID, getTraceId());
|
||||
getRequestType().ifPresent(requestType -> request.getHeaders().add(HEADER_FIELD_TYPE_ID, requestType));
|
||||
try {
|
||||
return execution.execute(request, body);
|
||||
} finally {
|
||||
request.getHeaders().remove(HEADER_FIELD_TRACE_ID);
|
||||
request.getHeaders().remove(HEADER_FIELD_TYPE_ID);
|
||||
}
|
||||
}
|
||||
|
||||
// HandlerInterceptor
|
||||
@Override
|
||||
public boolean preHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response,
|
||||
@NonNull Object handler) {
|
||||
String traceId = extractTraceId(request);
|
||||
String requestType = extractRequestType(request);
|
||||
InterceptorCloseables closeable = set(traceId, requestType);
|
||||
request.setAttribute(CLASS_NAME, closeable);
|
||||
return true;
|
||||
}
|
||||
|
||||
public static String extractTraceId(HttpServletRequest request) {
|
||||
return Optional.ofNullable(request.getHeader(HEADER_FIELD_TRACE_ID)).filter(s -> !s.isBlank())
|
||||
.or(() -> Optional.ofNullable(request.getHeader(HEADER_FIELD_B3_TRACE_ID)).filter(s -> !s.isBlank()))
|
||||
.orElse(UUID.randomUUID().toString());
|
||||
}
|
||||
|
||||
public static String extractRequestType(HttpServletRequest request) {
|
||||
return Optional.ofNullable(request.getHeader(HEADER_FIELD_TYPE_ID))
|
||||
.filter(reqType -> !reqType.isBlank())
|
||||
.orElse(null);
|
||||
}
|
||||
|
||||
// HandlerInterceptor
|
||||
@Override
|
||||
public void postHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response,
|
||||
@NonNull Object handler, ModelAndView modelAndView) {
|
||||
Optional.ofNullable(request.getAttribute(CLASS_NAME))
|
||||
.filter(InterceptorCloseables.class::isInstance)
|
||||
.map(InterceptorCloseables.class::cast)
|
||||
.ifPresent(InterceptorCloseables::close);
|
||||
}
|
||||
}
|
||||
-419
@@ -1,419 +0,0 @@
|
||||
package de.twomartens.template.interceptor;
|
||||
|
||||
import jakarta.servlet.Filter;
|
||||
import jakarta.servlet.FilterChain;
|
||||
import jakarta.servlet.ServletException;
|
||||
import jakarta.servlet.ServletRequest;
|
||||
import jakarta.servlet.ServletResponse;
|
||||
import jakarta.servlet.http.HttpServletRequest;
|
||||
import jakarta.servlet.http.HttpServletResponse;
|
||||
import java.io.IOException;
|
||||
import java.net.URL;
|
||||
import java.nio.charset.Charset;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.Objects;
|
||||
import java.util.Optional;
|
||||
import java.util.TreeSet;
|
||||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
import lombok.Builder;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.log4j.Log4j2;
|
||||
import org.apache.logging.log4j.Marker;
|
||||
import org.apache.logging.log4j.MarkerManager.Log4jMarker;
|
||||
import org.apache.logging.log4j.message.StringMapMessage;
|
||||
import org.springframework.http.HttpHeaders;
|
||||
import org.springframework.http.HttpRequest;
|
||||
import org.springframework.http.MediaType;
|
||||
import org.springframework.http.client.ClientHttpRequestExecution;
|
||||
import org.springframework.http.client.ClientHttpRequestInterceptor;
|
||||
import org.springframework.http.client.ClientHttpResponse;
|
||||
import org.springframework.lang.NonNull;
|
||||
import org.springframework.util.StreamUtils;
|
||||
import org.springframework.web.util.ContentCachingRequestWrapper;
|
||||
import org.springframework.web.util.ContentCachingResponseWrapper;
|
||||
|
||||
@Log4j2
|
||||
@RequiredArgsConstructor
|
||||
public class LoggingInterceptorRest implements Filter, ClientHttpRequestInterceptor {
|
||||
|
||||
public static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
|
||||
public static final Marker MARKER = new Log4jMarker("communication");
|
||||
|
||||
private static final int MAX_LOG_SIZE = 20480; // 20 KB - logging could fail with bigger logmessages
|
||||
|
||||
public static final String DIRECTION_IN = "inbound";
|
||||
public static final String DIRECTION_OUT = "outbound";
|
||||
public static final String PROTOCOL_NAME = "http";
|
||||
|
||||
public static final String PARAM_URL_FULL = "url.full";
|
||||
public static final String PARAM_URL_DOMAIN = "url.domain";
|
||||
public static final String PARAM_URL_EXTENSION = "url.extension";
|
||||
public static final String PARAM_URL_PATH = "url.path";
|
||||
public static final String PARAM_URL_PORT = "url.port";
|
||||
public static final String PARAM_URL_SCHEME = "url.scheme";
|
||||
public static final String PARAM_URL_QUERY = "url.query";
|
||||
public static final String PARAM_BUSINESS_TYPE = "http.request.type";
|
||||
public static final String PARAM_REQUEST_BODY = "http.request.body.content";
|
||||
public static final String PARAM_RESPONSE_BODY = "http.response.body.content";
|
||||
public static final String PARAM_RESPONSE_STATUS = "http.response.status_code";
|
||||
public static final String PARAM_REQUEST_HEADERS = "http.request.headers";
|
||||
public static final String PARAM_RESPONSE_HEADERS = "http.response.headers";
|
||||
public static final String PARAM_REQUEST_BYTES = "http.request.body.bytes";
|
||||
public static final String PARAM_RESPONSE_BYTES = "http.response.body.bytes";
|
||||
public static final String PARAM_REQUEST_MIMETYPE = "http.request.mime_type";
|
||||
public static final String PARAM_RESPONSE_MIMETYPE = "http.response.mime_type";
|
||||
public static final String PARAM_REQUEST_METHOD = "http.request.method";
|
||||
public static final String PARAM_REQUEST_REFERER = "http.request.referrer";
|
||||
public static final String PARAM_REQUEST_TIME = "event.start";
|
||||
public static final String PARAM_RESPONSE_TIME = "event.end";
|
||||
public static final String PARAM_DURATION = "event.duration";
|
||||
public static final String PARAM_USER_AGENT = "user_agent.original";
|
||||
public static final String PARAM_DIRECTION = "network.direction";
|
||||
public static final String PARAM_PROTOCOL = "network.protocol";
|
||||
|
||||
private final FieldLogBehaviour requestLogBehaviour;
|
||||
private final FieldLogBehaviour responseLogBehaviour;
|
||||
private final Clock clock;
|
||||
|
||||
public LoggingInterceptorRest(Clock clock) {
|
||||
this(FieldLogBehaviour.NEVER, FieldLogBehaviour.NEVER, clock);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void doFilter(ServletRequest request, ServletResponse response,
|
||||
FilterChain chain) throws IOException, ServletException {
|
||||
ZonedDateTime requestTime = ZonedDateTime.now(clock);
|
||||
HttpServletRequest httpRequest = (HttpServletRequest) request;
|
||||
ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper(httpRequest);
|
||||
ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(
|
||||
(HttpServletResponse) response);
|
||||
|
||||
byte[] fullResponseBytes = null;
|
||||
Throwable throwable = null;
|
||||
String responseBody = null;
|
||||
int httpStatusCode = -1;
|
||||
|
||||
try {
|
||||
try {
|
||||
chain.doFilter(
|
||||
requestLogBehaviour != FieldLogBehaviour.NEVER ? requestWrapper : httpRequest,
|
||||
responseWrapper);
|
||||
if (responseLogBehaviour != FieldLogBehaviour.NEVER) {
|
||||
fullResponseBytes = responseWrapper.getContentAsByteArray();
|
||||
}
|
||||
httpStatusCode = responseWrapper.getStatus();
|
||||
} finally {
|
||||
responseWrapper.copyBodyToResponse();
|
||||
}
|
||||
} catch (Exception e) {
|
||||
throwable = e;
|
||||
throw e;
|
||||
} finally {
|
||||
try {
|
||||
int responseSize = responseWrapper.getContentSize();
|
||||
Map<String, Collection<String>> responseHeaders = extractHeaders(
|
||||
responseWrapper.getHeaderNames().iterator(),
|
||||
s -> responseWrapper.getHeaders(s).iterator());
|
||||
if ((responseLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| responseLogBehaviour == FieldLogBehaviour.ALWAYS) && fullResponseBytes != null) {
|
||||
responseBody = new String(fullResponseBytes,
|
||||
determineResponseEncoding(responseHeaders, fullResponseBytes));
|
||||
}
|
||||
URL requestUrl = new URL(Optional.ofNullable(httpRequest.getQueryString())
|
||||
.map(qs -> httpRequest.getRequestURL().toString() + "?" + qs)
|
||||
.orElse(httpRequest.getRequestURL().toString()));
|
||||
Map<String, Collection<String>> requestHeaders = extractHeaders(
|
||||
httpRequest.getHeaderNames().asIterator(),
|
||||
s -> httpRequest.getHeaders(s).asIterator());
|
||||
String requestBody = null;
|
||||
String businessType = null;
|
||||
if (requestLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| requestLogBehaviour == FieldLogBehaviour.ALWAYS) {
|
||||
byte[] fullRequestBytes = requestWrapper.getContentAsByteArray();
|
||||
if (fullRequestBytes != null) {
|
||||
requestBody = new String(fullRequestBytes,
|
||||
determineRequestEncoding(requestHeaders, fullRequestBytes));
|
||||
}
|
||||
businessType = determineBusinessType(requestUrl, requestBody);
|
||||
}
|
||||
log(LogMessage.builder()
|
||||
.requestHeaders(requestHeaders)
|
||||
.responseHeaders(responseHeaders)
|
||||
.url(requestUrl)
|
||||
.method(httpRequest.getMethod())
|
||||
.requestMimeType(typeToString(request.getContentType()))
|
||||
.responseMimeType(typeToString(response.getContentType()))
|
||||
.requestBody(requestBody)
|
||||
.responseBody(responseBody)
|
||||
.requestSize(httpRequest.getContentLength())
|
||||
.responseSize(responseSize)
|
||||
.httpStatus(httpStatusCode)
|
||||
.direction(DIRECTION_IN)
|
||||
.requestTime(requestTime)
|
||||
.responseTime(ZonedDateTime.now(clock))
|
||||
.traceId(HeaderInterceptorRest.extractTraceId(httpRequest))
|
||||
.requestType(HeaderInterceptorRest.extractRequestType(httpRequest))
|
||||
.businessType(businessType)
|
||||
.throwable(throwable)
|
||||
.build());
|
||||
} catch (RuntimeException e) {
|
||||
log.error(e.toString(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isError(int httpStatusCode) {
|
||||
return httpStatusCode >= 400 && httpStatusCode < 600;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
@Override
|
||||
public ClientHttpResponse intercept(@NonNull HttpRequest request,
|
||||
@NonNull byte[] requestBytes, @NonNull ClientHttpRequestExecution execution)
|
||||
throws IOException {
|
||||
|
||||
ZonedDateTime requestTime = ZonedDateTime.now(clock);
|
||||
int responseSize = 0;
|
||||
Map<String, Collection<String>> responseHeaders = Collections.emptyMap();
|
||||
MediaType responseMediaType = null;
|
||||
int httpStatusCode = -1;
|
||||
Throwable throwable = null;
|
||||
String requestBody = null;
|
||||
String responseBody = null;
|
||||
String businessType = null;
|
||||
|
||||
try {
|
||||
BufferingClientHttpResponseWrapper result = new BufferingClientHttpResponseWrapper(
|
||||
execution.execute(request, requestBytes));
|
||||
byte[] responseBytes = StreamUtils.copyToByteArray(result.getBody());
|
||||
responseSize = responseBytes.length;
|
||||
responseHeaders = extractHeaders(result.getHeaders());
|
||||
responseMediaType = result.getHeaders().getContentType();
|
||||
httpStatusCode = result.getStatusCode().value();
|
||||
if (responseLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| responseLogBehaviour == FieldLogBehaviour.ALWAYS) {
|
||||
responseBody = new String(responseBytes,
|
||||
determineRequestEncoding(responseHeaders, responseBytes));
|
||||
}
|
||||
return result;
|
||||
} catch (Exception e) {
|
||||
throwable = e;
|
||||
throw e;
|
||||
} finally {
|
||||
try {
|
||||
URL url = request.getURI().toURL();
|
||||
Map<String, Collection<String>> requestHeaders = extractHeaders(request.getHeaders());
|
||||
if (requestLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| requestLogBehaviour == FieldLogBehaviour.ALWAYS) {
|
||||
requestBody = new String(requestBytes,
|
||||
determineRequestEncoding(requestHeaders, requestBytes));
|
||||
businessType = determineBusinessType(url, requestBody);
|
||||
}
|
||||
log(LogMessage.builder()
|
||||
.requestHeaders(requestHeaders)
|
||||
.responseHeaders(responseHeaders)
|
||||
.url(url)
|
||||
.method(Objects.requireNonNull(request.getMethod()).toString())
|
||||
.requestMimeType(typeToString(request.getHeaders().getContentType()))
|
||||
.requestBody(requestBody)
|
||||
.responseBody(responseBody)
|
||||
.responseMimeType(typeToString(responseMediaType))
|
||||
.requestSize(requestBytes.length)
|
||||
.responseSize(responseSize)
|
||||
.httpStatus(httpStatusCode)
|
||||
.direction(DIRECTION_OUT)
|
||||
.requestTime(requestTime)
|
||||
.responseTime(ZonedDateTime.now(clock))
|
||||
.businessType(businessType)
|
||||
.throwable(throwable)
|
||||
.build());
|
||||
} catch (RuntimeException e) {
|
||||
log.error(e.toString(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void log(LogMessage logMessage) {
|
||||
StringMapMessage stringMapMessage = new StringMapMessage();
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_HEADERS,
|
||||
toHeaderString(logMessage.requestHeaders()));
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_HEADERS,
|
||||
toHeaderString(logMessage.responseHeaders()));
|
||||
addLogString(stringMapMessage, PARAM_URL_FULL, logMessage.url().toString());
|
||||
addLogString(stringMapMessage, PARAM_URL_DOMAIN, logMessage.url().getHost());
|
||||
addLogString(stringMapMessage, PARAM_URL_EXTENSION,
|
||||
extractExtension(logMessage.url().getPath()));
|
||||
addLogString(stringMapMessage, PARAM_URL_PATH, logMessage.url().getPath());
|
||||
addLogString(stringMapMessage, PARAM_URL_PORT, Integer.toString(logMessage.url().getPort()));
|
||||
addLogString(stringMapMessage, PARAM_URL_SCHEME, logMessage.url().getProtocol());
|
||||
addLogString(stringMapMessage, PARAM_URL_QUERY, logMessage.url().getQuery());
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_METHOD, logMessage.method());
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_REFERER,
|
||||
getHeader(logMessage.requestHeaders(), HttpHeaders.REFERER));
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_MIMETYPE, logMessage.requestMimeType());
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_MIMETYPE, logMessage.responseMimeType());
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_BYTES, Integer.toString(logMessage.requestSize()));
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_BYTES,
|
||||
Integer.toString(logMessage.responseSize()));
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_STATUS,
|
||||
Integer.toString(logMessage.httpStatus()));
|
||||
addLogString(stringMapMessage, PARAM_DIRECTION, logMessage.direction());
|
||||
addLogString(stringMapMessage, PARAM_PROTOCOL, PROTOCOL_NAME);
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_TIME,
|
||||
logMessage.requestTime().format(DATE_TIME_FORMATTER));
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_TIME,
|
||||
logMessage.responseTime().format(DATE_TIME_FORMATTER));
|
||||
addLogString(stringMapMessage, PARAM_DURATION,
|
||||
Long.toString(getDurationBetweenRequestAndResponseTime(logMessage).toNanos()));
|
||||
addLogString(stringMapMessage, PARAM_USER_AGENT,
|
||||
getHeader(logMessage.requestHeaders(), HttpHeaders.USER_AGENT));
|
||||
addLogString(stringMapMessage, HeaderInterceptor.LOGGER_TRACE_ID, logMessage.traceId());
|
||||
addLogString(stringMapMessage, HeaderInterceptor.LOGGER_REQTYPE_ID, logMessage.requestType());
|
||||
addLogString(stringMapMessage, PARAM_BUSINESS_TYPE, logMessage.businessType());
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_BODY, cutToMaxLength(logMessage.requestBody()));
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_BODY, cutToMaxLength(logMessage.responseBody()));
|
||||
|
||||
log.debug(MARKER, stringMapMessage, logMessage.throwable());
|
||||
}
|
||||
|
||||
private Duration getDurationBetweenRequestAndResponseTime(LogMessage logMessage) {
|
||||
return Duration.between(logMessage.requestTime(), logMessage.responseTime());
|
||||
}
|
||||
|
||||
private String getHeader(Map<String, Collection<String>> headers, String headerKey) {
|
||||
return headers.entrySet().stream()
|
||||
.filter(e -> e.getKey().equalsIgnoreCase(headerKey))
|
||||
.flatMap(e -> e.getValue().stream())
|
||||
.findAny()
|
||||
.orElse(null);
|
||||
}
|
||||
|
||||
private void addLogString(StringMapMessage stringMapMessage, String key, String value) {
|
||||
if (value != null && !value.isBlank()) {
|
||||
stringMapMessage.with(key, value.trim());
|
||||
}
|
||||
}
|
||||
|
||||
private static Map<String, Collection<String>> extractHeaders(Iterator<String> headerNames,
|
||||
Function<String, Iterator<String>> headerValuesSupplier) {
|
||||
Map<String, Collection<String>> requestHeaders = new HashMap<>();
|
||||
while (headerNames.hasNext()) {
|
||||
String name = headerNames.next();
|
||||
Collection<String> values = requestHeaders.computeIfAbsent(name, n -> new TreeSet<>());
|
||||
Iterator<String> headerValues = headerValuesSupplier.apply(name);
|
||||
while (headerValues.hasNext()) {
|
||||
values.add(headerValues.next());
|
||||
}
|
||||
}
|
||||
return requestHeaders;
|
||||
}
|
||||
|
||||
private static Map<String, Collection<String>> extractHeaders(HttpHeaders headers) {
|
||||
Map<String, Collection<String>> result = new HashMap<>();
|
||||
for (Entry<String, List<String>> entry : headers.entrySet()) {
|
||||
result.put(entry.getKey(), new ArrayList<>(entry.getValue()));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private static String toHeaderString(Map<String, Collection<String>> headerMap) {
|
||||
return headerMap.entrySet().stream()
|
||||
.flatMap(es -> es.getValue().stream().map(v -> new KeyValuePair(es.getKey(), v)))
|
||||
.map(kv -> kv.key() + "=" + kv.value())
|
||||
.collect(Collectors.joining("\n"));
|
||||
}
|
||||
|
||||
private static String typeToString(String contentType) {
|
||||
try {
|
||||
return Optional.ofNullable(contentType)
|
||||
.map(MediaType::parseMediaType)
|
||||
.map(LoggingInterceptorRest::typeToString)
|
||||
.orElse(null);
|
||||
} catch (RuntimeException e) {
|
||||
log.info(e.toString(), e);
|
||||
return e.toString();
|
||||
}
|
||||
}
|
||||
|
||||
private static String typeToString(MediaType mediaType) {
|
||||
try {
|
||||
return Optional.ofNullable(mediaType)
|
||||
.map(m -> m.getType() + "/" + m.getSubtype())
|
||||
.orElse(null);
|
||||
} catch (RuntimeException e) {
|
||||
log.info(e.toString(), e);
|
||||
return e.toString();
|
||||
}
|
||||
}
|
||||
|
||||
private static String extractExtension(String fileName) {
|
||||
return Optional.ofNullable(fileName)
|
||||
.filter(name -> name.contains("."))
|
||||
.map(name -> name.substring(name.lastIndexOf('.') + 1))
|
||||
.orElse(null);
|
||||
}
|
||||
|
||||
private static String cutToMaxLength(String string) {
|
||||
if (string != null && string.length() > MAX_LOG_SIZE) {
|
||||
return string.substring(0, MAX_LOG_SIZE);
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
/**
|
||||
* usually returns null, but can be overridden to implement more complex logic
|
||||
*/
|
||||
public String determineBusinessType(URL requestUrl, String requestBody) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* usually returns UTF-8, but can be overridden to implement more complex logic
|
||||
*/
|
||||
public Charset determineRequestEncoding(Map<String, Collection<String>> requestHeaders,
|
||||
byte[] fullRequest) {
|
||||
return StandardCharsets.UTF_8;
|
||||
}
|
||||
|
||||
/**
|
||||
* usually returns UTF-8, but can be overridden to implement more complex logic
|
||||
*/
|
||||
public Charset determineResponseEncoding(Map<String, Collection<String>> responseHeaders,
|
||||
byte[] fullResponse) {
|
||||
return StandardCharsets.UTF_8;
|
||||
}
|
||||
|
||||
@Builder
|
||||
private record LogMessage(Map<String, Collection<String>> requestHeaders,
|
||||
Map<String, Collection<String>> responseHeaders, URL url, String method,
|
||||
String requestMimeType, String responseMimeType, String requestBody,
|
||||
String responseBody,
|
||||
int requestSize, int responseSize, int httpStatus, String direction,
|
||||
ZonedDateTime requestTime, ZonedDateTime responseTime, String traceId,
|
||||
String requestType,
|
||||
String businessType, Throwable throwable) {
|
||||
|
||||
}
|
||||
|
||||
private record KeyValuePair(String key, String value) {
|
||||
|
||||
}
|
||||
|
||||
public enum FieldLogBehaviour {
|
||||
NEVER, ONLY_ON_ERROR, ALWAYS
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package de.twomartens.template.mapper.v1;
|
||||
|
||||
import de.twomartens.template.model.db.Greeting;
|
||||
import org.mapstruct.CollectionMappingStrategy;
|
||||
import org.mapstruct.Mapper;
|
||||
import org.mapstruct.Mapping;
|
||||
import org.mapstruct.NullValueCheckStrategy;
|
||||
import org.mapstruct.ReportingPolicy;
|
||||
|
||||
@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED,
|
||||
nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS,
|
||||
unmappedTargetPolicy = ReportingPolicy.IGNORE)
|
||||
public interface GreetingMapper {
|
||||
|
||||
de.twomartens.template.model.dto.v1.Greeting map(Greeting greeting);
|
||||
|
||||
@Mapping(target = "id", ignore = true)
|
||||
@Mapping(target = "created", ignore = true)
|
||||
@Mapping(target = "lastModified", ignore = true)
|
||||
Greeting map(de.twomartens.template.model.dto.v1.Greeting greeting);
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
package de.twomartens.template.model.db;
|
||||
|
||||
import java.util.Date;
|
||||
import lombok.AccessLevel;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.NoArgsConstructor;
|
||||
import lombok.Setter;
|
||||
import lombok.ToString;
|
||||
import lombok.experimental.FieldDefaults;
|
||||
import org.bson.types.ObjectId;
|
||||
import org.springframework.data.annotation.CreatedDate;
|
||||
import org.springframework.data.annotation.Id;
|
||||
import org.springframework.data.annotation.LastModifiedDate;
|
||||
import org.springframework.data.mongodb.core.mapping.Document;
|
||||
|
||||
@Document
|
||||
@Getter
|
||||
@Setter
|
||||
@Builder
|
||||
@EqualsAndHashCode
|
||||
@ToString
|
||||
@FieldDefaults(level = AccessLevel.PRIVATE)
|
||||
@NoArgsConstructor(force = true, access = AccessLevel.PRIVATE)
|
||||
@AllArgsConstructor(access = AccessLevel.PRIVATE)
|
||||
public class Greeting {
|
||||
|
||||
@Id
|
||||
ObjectId id;
|
||||
|
||||
@CreatedDate
|
||||
Date created;
|
||||
|
||||
@LastModifiedDate
|
||||
Date lastModified;
|
||||
|
||||
String message;
|
||||
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package de.twomartens.template.model.dto;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.NoArgsConstructor;
|
||||
import lombok.Setter;
|
||||
import lombok.ToString;
|
||||
import lombok.experimental.FieldDefaults;
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
@Builder
|
||||
@EqualsAndHashCode
|
||||
@ToString
|
||||
@FieldDefaults(level = AccessLevel.PRIVATE)
|
||||
@NoArgsConstructor(force = true, access = AccessLevel.PRIVATE)
|
||||
@AllArgsConstructor(access = AccessLevel.PRIVATE)
|
||||
public class ErrorMessage {
|
||||
|
||||
String message;
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package de.twomartens.template.model.dto.v1;
|
||||
|
||||
import io.swagger.v3.oas.annotations.media.Schema;
|
||||
import lombok.AccessLevel;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.NoArgsConstructor;
|
||||
import lombok.Setter;
|
||||
import lombok.ToString;
|
||||
import lombok.experimental.FieldDefaults;
|
||||
import org.springframework.lang.NonNull;
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
@Builder
|
||||
@EqualsAndHashCode
|
||||
@ToString
|
||||
@FieldDefaults(level = AccessLevel.PRIVATE)
|
||||
@NoArgsConstructor(force = true, access = AccessLevel.PRIVATE)
|
||||
@AllArgsConstructor(access = AccessLevel.PRIVATE)
|
||||
@Schema(description = "Data container for a greeting message")
|
||||
public class Greeting {
|
||||
|
||||
@NonNull
|
||||
@Schema(description = "Data container for a greeting message", example = "Hello Helmut!",
|
||||
defaultValue = "Hello World!")
|
||||
private final String message;
|
||||
|
||||
}
|
||||
-84
@@ -1,84 +0,0 @@
|
||||
package de.twomartens.template.monitoring.actuator;
|
||||
|
||||
import java.io.Closeable;
|
||||
import java.io.IOException;
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.slf4j.MDC;
|
||||
import org.slf4j.MDC.MDCCloseable;
|
||||
import org.springframework.boot.actuate.health.Health;
|
||||
import org.springframework.boot.actuate.health.HealthIndicator;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
|
||||
@Slf4j
|
||||
@RequiredArgsConstructor
|
||||
public abstract class AbstractHealthIndicator implements HealthIndicator {
|
||||
|
||||
public static final String HOST = "localhost";
|
||||
public static final String HTTP_PREFIX = "http://";
|
||||
public static final String HOST_PORT_SEPERATOR = ":";
|
||||
public static final String PATH_SEPERATOR = "/";
|
||||
public static final String PARAMETER_SEPERATOR = "?";
|
||||
public static final String DETAIL_ENDPOINT_KEY = "endpoint";
|
||||
|
||||
private final String logStatusDownMessage = String.format("health indicator '%s' invoked with status '%s'",
|
||||
indicatorName(), Status.DOWN.getCode());
|
||||
private final String logStatusUpMessage = String.format("health indicator '%s' invoked with status '%s'",
|
||||
indicatorName(), Status.UP.getCode());
|
||||
private final Clock clock;
|
||||
private final Preparable preparable;
|
||||
private boolean firstTime = true;
|
||||
|
||||
/**
|
||||
* main method that determines the health of the service
|
||||
*/
|
||||
protected abstract Health determineHealth();
|
||||
|
||||
@Override
|
||||
public Health health() {
|
||||
try (Closeable ignored = preparable.prepare()) {
|
||||
Health result = null;
|
||||
Exception exception = null;
|
||||
long start = clock.millis();
|
||||
try {
|
||||
result = determineHealth();
|
||||
} catch (RuntimeException e) {
|
||||
exception = e;
|
||||
result = Health.down().withException(e).build();
|
||||
} finally {
|
||||
logInvocation(result, exception, start, clock.millis());
|
||||
}
|
||||
return result;
|
||||
} catch (IOException e) {
|
||||
log.error("unexpected exception occurred", e);
|
||||
return Health.down(e).build();
|
||||
}
|
||||
}
|
||||
|
||||
private void logInvocation(Health health, Exception exception, long start, long end) {
|
||||
Duration duration = Duration.ofMillis(end - start);
|
||||
try (MDCCloseable ignored = MDC.putCloseable("event.duration", Long.toString(duration.toNanos()))) {
|
||||
if (exception != null || health == null) {
|
||||
log.error(logStatusDownMessage, exception);
|
||||
firstTime = true;
|
||||
} else if (health.getStatus() == Status.DOWN) {
|
||||
log.warn(logStatusDownMessage);
|
||||
firstTime = true;
|
||||
} else if (firstTime) {
|
||||
log.info(logStatusUpMessage);
|
||||
firstTime = false;
|
||||
} else {
|
||||
log.trace(logStatusUpMessage);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private String indicatorName() {
|
||||
return this.getClass().getSimpleName()
|
||||
.replace("HealthIndicator", "")
|
||||
.toLowerCase();
|
||||
}
|
||||
|
||||
}
|
||||
-37
@@ -1,37 +0,0 @@
|
||||
package de.twomartens.template.monitoring.actuator;
|
||||
|
||||
import de.twomartens.template.monitoring.statusprobe.StatusProbe;
|
||||
import java.time.Clock;
|
||||
import java.util.Optional;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.boot.actuate.health.Health;
|
||||
import org.springframework.boot.actuate.health.Health.Builder;
|
||||
import org.springframework.boot.actuate.health.HealthIndicator;
|
||||
|
||||
@Slf4j
|
||||
public abstract class AbstractStatusProbeHealthIndicator extends AbstractHealthIndicator
|
||||
implements HealthIndicator {
|
||||
|
||||
public static final String MESSAGE_KEY = "message";
|
||||
public static final String LAST_STATUS_CHANGE_KEY = "lastStatusChange";
|
||||
|
||||
private final StatusProbe statusProbe;
|
||||
|
||||
public AbstractStatusProbeHealthIndicator(Clock timeProvider, Preparable headerInterceptor,
|
||||
StatusProbe statusProbe) {
|
||||
super(timeProvider, headerInterceptor);
|
||||
this.statusProbe = statusProbe;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected Health determineHealth() {
|
||||
Builder healthBuilder = Health.status(statusProbe.getStatus());
|
||||
Optional.ofNullable(statusProbe.getLastStatusChange())
|
||||
.ifPresent(l -> healthBuilder.withDetail(LAST_STATUS_CHANGE_KEY, l));
|
||||
Optional.ofNullable(statusProbe.getThrowable()).ifPresent(healthBuilder::withException);
|
||||
Optional.ofNullable(statusProbe.getMessage())
|
||||
.ifPresent(m -> healthBuilder.withDetail(MESSAGE_KEY, m));
|
||||
return healthBuilder.build();
|
||||
}
|
||||
|
||||
}
|
||||
-10
@@ -1,10 +0,0 @@
|
||||
package de.twomartens.template.monitoring.actuator;
|
||||
|
||||
import java.io.Closeable;
|
||||
|
||||
@FunctionalInterface
|
||||
public interface Preparable {
|
||||
|
||||
Closeable prepare();
|
||||
|
||||
}
|
||||
-65
@@ -1,65 +0,0 @@
|
||||
package de.twomartens.template.monitoring.actuator;
|
||||
|
||||
import de.twomartens.template.interceptor.HeaderInterceptorRest;
|
||||
import java.security.SecureRandom;
|
||||
import java.time.Clock;
|
||||
import java.util.Optional;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.boot.actuate.health.Health;
|
||||
import org.springframework.boot.actuate.health.HealthIndicator;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
import org.springframework.boot.autoconfigure.web.ServerProperties;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.stereotype.Component;
|
||||
import org.springframework.web.client.RestTemplate;
|
||||
|
||||
/**
|
||||
* A Health check which checks if the rest services are working.
|
||||
* <p>
|
||||
* If you have a complex service, you should think about an easy greeting or echo service, which
|
||||
* only tests the
|
||||
* network/service stack and not the full application.
|
||||
* <p>
|
||||
* The health check will be called by kubernetes to check if the container/pod should be in load
|
||||
* balancing. It is possible
|
||||
* to have as much health checks as you like.
|
||||
* <p>
|
||||
* There should be a health check which is ok not before all data is loaded.
|
||||
*/
|
||||
@Slf4j
|
||||
@Component
|
||||
public class RestHealthIndicator extends AbstractHealthIndicator implements HealthIndicator {
|
||||
|
||||
private static final String URL_PATH = "/template/v1/healthCheck";
|
||||
private static final String GET_PARAMETER = "message=";
|
||||
|
||||
private final SecureRandom randomizer = new SecureRandom();
|
||||
private final RestTemplate restTemplateRestHealthIndicator;
|
||||
private final String urlPrefix;
|
||||
|
||||
public RestHealthIndicator(Clock clock, HeaderInterceptorRest interceptor,
|
||||
ServerProperties serverProperties, RestTemplate restTemplateRestHealthIndicator) {
|
||||
super(clock, interceptor::markAsHealthCheck);
|
||||
this.restTemplateRestHealthIndicator = restTemplateRestHealthIndicator;
|
||||
urlPrefix = HTTP_PREFIX + HOST + HOST_PORT_SEPERATOR + serverProperties.getPort()
|
||||
+ URL_PATH + PARAMETER_SEPERATOR + GET_PARAMETER;
|
||||
}
|
||||
|
||||
/**
|
||||
* main method that determines the health of the service
|
||||
*/
|
||||
@Override
|
||||
protected Health determineHealth() {
|
||||
String random = Integer.toString(randomizer.nextInt(100000, 999999));
|
||||
String url = urlPrefix + "{random}";
|
||||
ResponseEntity<String> response = restTemplateRestHealthIndicator.getForEntity(url, String.class, random);
|
||||
Status status = Optional.ofNullable(response.getBody())
|
||||
.filter(random::equals)
|
||||
.map(m -> Status.UP)
|
||||
.orElse(Status.DOWN);
|
||||
return Health.status(status)
|
||||
.withDetail(DETAIL_ENDPOINT_KEY, url)
|
||||
.build();
|
||||
}
|
||||
|
||||
}
|
||||
-33
@@ -1,33 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
|
||||
public class CountBasedStatusProbe extends StatusProbe {
|
||||
|
||||
private final AtomicInteger failureCount = new AtomicInteger(0);
|
||||
|
||||
private final int maxFailureCount;
|
||||
|
||||
public CountBasedStatusProbe(int maxFailureCount, Clock clock, StatusProbeCriticality criticality, String name,
|
||||
StatusProbeLogger statusProbeLogger) {
|
||||
super(clock, criticality, name, statusProbeLogger);
|
||||
this.maxFailureCount = maxFailureCount;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected synchronized void setStatus(Status status, Throwable throwable, String message) {
|
||||
if (status == Status.DOWN) {
|
||||
int failureCount = this.failureCount.incrementAndGet();
|
||||
if (failureCount > maxFailureCount) {
|
||||
super.setStatus(status, throwable, message);
|
||||
}
|
||||
} else if (status == Status.UP) {
|
||||
this.failureCount.set(0);
|
||||
super.setStatus(status, throwable, message);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
-63
@@ -1,63 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
|
||||
|
||||
/**
|
||||
* uses the percentage of down statuses within a given period (default: 1 min) to determine if status of probe is down.
|
||||
* this is meant to be used to avoid flickering status probes on services that have lots of status updates. When there
|
||||
* is no significant amount of requests during one scheduling period, the behavior may be arbitrary.
|
||||
*/
|
||||
public class PercentageBasedStatusProbe extends StatusProbe implements ScheduledStatusProbe {
|
||||
|
||||
private final int maxFailurePercent;
|
||||
|
||||
private int requestCount = 0;
|
||||
private int downCount = 0;
|
||||
private Throwable throwable;
|
||||
private String message;
|
||||
|
||||
public PercentageBasedStatusProbe(int maxFailurePercent, Clock clock,
|
||||
ThreadPoolTaskScheduler threadPoolTaskScheduler, StatusProbeCriticality criticality, String name,
|
||||
StatusProbeLogger statusProbeLogger) {
|
||||
this(maxFailurePercent, clock, threadPoolTaskScheduler, Duration.ofMinutes(1), criticality, name,
|
||||
statusProbeLogger);
|
||||
}
|
||||
|
||||
public PercentageBasedStatusProbe(int maxFailurePercent, Clock clock,
|
||||
ThreadPoolTaskScheduler threadPoolTaskScheduler, Duration schedulePeriod, StatusProbeCriticality criticality,
|
||||
String name, StatusProbeLogger statusProbeLogger) {
|
||||
super(clock, criticality, name, statusProbeLogger);
|
||||
this.maxFailurePercent = maxFailurePercent;
|
||||
scheduleTask(threadPoolTaskScheduler, schedulePeriod);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected synchronized void setStatus(Status status, Throwable throwable, String message) {
|
||||
if (status == Status.DOWN) {
|
||||
downCount++;
|
||||
this.throwable = throwable;
|
||||
this.message = message;
|
||||
}
|
||||
requestCount++;
|
||||
}
|
||||
|
||||
private void reset() {
|
||||
requestCount = 0;
|
||||
downCount = 0;
|
||||
throwable = null;
|
||||
message = null;
|
||||
}
|
||||
|
||||
public synchronized void runScheduledTask() {
|
||||
if (requestCount > 0 && (downCount * 100.0 / requestCount) > maxFailurePercent) {
|
||||
super.setStatus(Status.DOWN, throwable, message);
|
||||
} else {
|
||||
super.setStatus(Status.UP, null, null);
|
||||
}
|
||||
reset();
|
||||
}
|
||||
|
||||
}
|
||||
-18
@@ -1,18 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
import java.time.Duration;
|
||||
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
|
||||
import org.springframework.scheduling.support.PeriodicTrigger;
|
||||
|
||||
public interface ScheduledStatusProbe {
|
||||
|
||||
void runScheduledTask();
|
||||
|
||||
default void scheduleTask(ThreadPoolTaskScheduler threadPoolTaskScheduler,
|
||||
Duration schedulePeriod) {
|
||||
PeriodicTrigger periodicTrigger = new PeriodicTrigger(
|
||||
Duration.ofSeconds(schedulePeriod.toSeconds()));
|
||||
threadPoolTaskScheduler.schedule(this::runScheduledTask, periodicTrigger);
|
||||
}
|
||||
|
||||
}
|
||||
-62
@@ -1,62 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZonedDateTime;
|
||||
import lombok.Getter;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
|
||||
@Getter
|
||||
public class StatusProbe {
|
||||
|
||||
private final Clock clock;
|
||||
|
||||
private Status status = Status.UP;
|
||||
private Throwable throwable = null;
|
||||
private String message = null;
|
||||
private ZonedDateTime lastStatusChange;
|
||||
private final StatusProbeLogger statusProbeLogger;
|
||||
private final String name;
|
||||
|
||||
public StatusProbe(Clock clock, StatusProbeCriticality criticality, String name,
|
||||
StatusProbeLogger statusProbeLogger) {
|
||||
this.clock = clock;
|
||||
this.name = name;
|
||||
this.statusProbeLogger = statusProbeLogger;
|
||||
statusProbeLogger.registerStatusProbe(name, criticality);
|
||||
}
|
||||
|
||||
protected void setStatus(Status status, Throwable throwable, String message) {
|
||||
if (status != this.status) {
|
||||
lastStatusChange = ZonedDateTime.now(clock);
|
||||
statusProbeLogger.logStatusChange(name, message, status, lastStatusChange, throwable);
|
||||
}
|
||||
this.status = status;
|
||||
this.throwable = throwable;
|
||||
this.message = message;
|
||||
}
|
||||
|
||||
public void up() {
|
||||
setStatus(Status.UP, null, null);
|
||||
}
|
||||
|
||||
public void up(String message) {
|
||||
setStatus(Status.UP, null, message);
|
||||
}
|
||||
|
||||
public void down() {
|
||||
setStatus(Status.DOWN, null, null);
|
||||
}
|
||||
|
||||
public void down(Throwable throwable) {
|
||||
setStatus(Status.DOWN, throwable, null);
|
||||
}
|
||||
|
||||
public void down(String message) {
|
||||
setStatus(Status.DOWN, null, message);
|
||||
}
|
||||
|
||||
protected void down(Throwable throwable, String message) {
|
||||
setStatus(Status.DOWN, throwable, message);
|
||||
}
|
||||
|
||||
}
|
||||
-7
@@ -1,7 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
|
||||
public enum StatusProbeCriticality {
|
||||
K1, K2, K3
|
||||
}
|
||||
|
||||
-124
@@ -1,124 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
import static de.twomartens.template.monitoring.statusprobe.StatusProbeCriticality.K1;
|
||||
import static de.twomartens.template.monitoring.statusprobe.StatusProbeCriticality.K2;
|
||||
import static de.twomartens.template.monitoring.statusprobe.StatusProbeCriticality.K3;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.apache.logging.log4j.Marker;
|
||||
import org.apache.logging.log4j.MarkerManager;
|
||||
import org.apache.logging.log4j.message.StringMapMessage;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
|
||||
public class StatusProbeLogger {
|
||||
|
||||
private static final Marker MARKER = MarkerManager.getMarker("statusprobe");
|
||||
|
||||
private static final String LABEL_CRITICALITY = "label.status.criticality";
|
||||
private static final String LABEL_STATUS = "label.status.status";
|
||||
private static final String LABEL_REASON = "label.status.reason";
|
||||
private static final String LABEL_MESSAGE = "label.status.description";
|
||||
private static final String LABEL_LAST_STATUS_CHANGE = "label.status.last_change";
|
||||
|
||||
private final Clock clock;
|
||||
private final Logger commLog;
|
||||
private final Map<ProbeIdent, Status> statusProbeToStatus = new HashMap<>();
|
||||
|
||||
public StatusProbeLogger(Clock clock) {
|
||||
this(clock, LogManager.getLogger("statusprobe"));
|
||||
}
|
||||
|
||||
/**
|
||||
* only for testing purposes
|
||||
*/
|
||||
StatusProbeLogger(Clock clock, Logger commLog) {
|
||||
this.clock = clock;
|
||||
this.commLog = commLog;
|
||||
}
|
||||
|
||||
public void registerStatusProbe(String name, StatusProbeCriticality criticality) {
|
||||
statusProbeToStatus.put(new ProbeIdent(name, criticality), Status.UP);
|
||||
logStatusChange(name, "Startup", Status.UP, ZonedDateTime.now(clock), null);
|
||||
}
|
||||
|
||||
public void logStatusChange(String name, String message, Status status, ZonedDateTime lastStatusChange,
|
||||
Throwable throwable) {
|
||||
ProbeIdent probeIdent = getProbeIdent(name);
|
||||
if (probeIdent == null) {
|
||||
probeIdent = new ProbeIdent(name, K1);
|
||||
}
|
||||
statusProbeToStatus.put(probeIdent, status);
|
||||
createLog(message, lastStatusChange, throwable);
|
||||
}
|
||||
|
||||
private ProbeIdent getProbeIdent(String name) {
|
||||
return statusProbeToStatus.keySet().stream().filter(key -> key.name.equals(name)).findFirst().orElse(null);
|
||||
}
|
||||
|
||||
private void createLog(String message, ZonedDateTime lastStatusChange, Throwable throwable) {
|
||||
Status overallStatus = getOverallStatus();
|
||||
StatusProbeCriticality criticality = getOverallCriticality();
|
||||
if (message == null) {
|
||||
message = "";
|
||||
}
|
||||
if (Status.UP.equals(overallStatus)) {
|
||||
commLog.info(MARKER, new StringMapMessage()
|
||||
.with(LABEL_CRITICALITY, criticality)
|
||||
.with(LABEL_STATUS, overallStatus)
|
||||
.with(LABEL_MESSAGE, message)
|
||||
.with(LABEL_LAST_STATUS_CHANGE, lastStatusChange));
|
||||
} else {
|
||||
commLog.error(MARKER, new StringMapMessage()
|
||||
.with(LABEL_CRITICALITY, criticality)
|
||||
.with(LABEL_STATUS, overallStatus)
|
||||
.with(LABEL_MESSAGE, message)
|
||||
.with(LABEL_REASON, getReason())
|
||||
.with(LABEL_LAST_STATUS_CHANGE, lastStatusChange), throwable);
|
||||
}
|
||||
}
|
||||
|
||||
private StatusProbeCriticality getOverallCriticality() {
|
||||
List<StatusProbeCriticality> crits = statusProbeToStatus.keySet().stream().map(key -> key.criticality).toList();
|
||||
return crits.contains(K1) ? K1 : crits.contains(K2) ? K2 : K3;
|
||||
}
|
||||
|
||||
private Status getOverallStatus() {
|
||||
if (statusProbeToStatus.containsValue(Status.DOWN)) {
|
||||
return Status.DOWN;
|
||||
}
|
||||
return Status.UP;
|
||||
}
|
||||
|
||||
private String getReason() {
|
||||
|
||||
List<ProbeIdent> probesDown = statusProbeToStatus.entrySet().stream()
|
||||
.filter(entry -> Status.DOWN.equals(entry.getValue()))
|
||||
.map(Map.Entry::getKey)
|
||||
.toList();
|
||||
|
||||
String reasonK1 = getDownStatusProbes(probesDown, K1);
|
||||
String reasonK2 = getDownStatusProbes(probesDown, K2);
|
||||
String reasonK3 = getDownStatusProbes(probesDown, K3);
|
||||
|
||||
return "%s%s%s".formatted(reasonK1, reasonK2, reasonK3).trim();
|
||||
}
|
||||
|
||||
private String getDownStatusProbes(List<ProbeIdent> probesDown, StatusProbeCriticality criticality) {
|
||||
List<String> downProbeNames = probesDown.stream().filter(probe -> probe.criticality.equals(criticality))
|
||||
.map(probe -> probe.name).toList();
|
||||
if (downProbeNames.size() > 0) {
|
||||
return criticality + " failed: " + String.join(",", downProbeNames) + "\n";
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
public record ProbeIdent(String name, StatusProbeCriticality criticality) {
|
||||
|
||||
}
|
||||
}
|
||||
-64
@@ -1,64 +0,0 @@
|
||||
package de.twomartens.template.monitoring.statusprobe;
|
||||
|
||||
import java.time.Clock;
|
||||
import java.time.Duration;
|
||||
import java.time.ZonedDateTime;
|
||||
import org.springframework.boot.actuate.health.Status;
|
||||
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
|
||||
|
||||
public class TimeBasedStatusProbe extends StatusProbe implements ScheduledStatusProbe {
|
||||
|
||||
private final Clock clock;
|
||||
|
||||
private final Duration maxFailureDuration;
|
||||
|
||||
private ZonedDateTime lastSuccess;
|
||||
|
||||
private Throwable throwable = null;
|
||||
|
||||
private String message = null;
|
||||
|
||||
public TimeBasedStatusProbe(Duration maxFailureDuration, Clock clock,
|
||||
ThreadPoolTaskScheduler threadPoolTaskScheduler, StatusProbeCriticality criticality, String name,
|
||||
StatusProbeLogger statusProbeLogger) {
|
||||
this(maxFailureDuration, clock, threadPoolTaskScheduler, Duration.ofMinutes(1), criticality, name,
|
||||
statusProbeLogger);
|
||||
}
|
||||
|
||||
public TimeBasedStatusProbe(Duration maxFailureDuration, Clock clock,
|
||||
ThreadPoolTaskScheduler threadPoolTaskScheduler, Duration schedulePeriod, StatusProbeCriticality criticality,
|
||||
String name, StatusProbeLogger statusProbeLogger) {
|
||||
super(clock, criticality, name, statusProbeLogger);
|
||||
this.clock = clock;
|
||||
this.maxFailureDuration = maxFailureDuration;
|
||||
this.lastSuccess = null;
|
||||
scheduleTask(threadPoolTaskScheduler, schedulePeriod);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected synchronized void setStatus(Status status, Throwable throwable, String message) {
|
||||
if (status == Status.DOWN) {
|
||||
this.throwable = throwable;
|
||||
this.message = message;
|
||||
} else if (status == Status.UP) {
|
||||
lastSuccess = ZonedDateTime.now(clock);
|
||||
super.setStatus(status, throwable, message);
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isOverdue() {
|
||||
if (lastSuccess == null) {
|
||||
return false;
|
||||
}
|
||||
Duration timeSinceLastSuccess = Duration.between(lastSuccess, ZonedDateTime.now(clock));
|
||||
return maxFailureDuration.minus(timeSinceLastSuccess).isNegative();
|
||||
}
|
||||
|
||||
public synchronized void runScheduledTask() {
|
||||
if (isOverdue()) {
|
||||
super.setStatus(Status.DOWN, throwable, message);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
-34
@@ -1,34 +0,0 @@
|
||||
package de.twomartens.template.property;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.NoArgsConstructor;
|
||||
import lombok.Setter;
|
||||
import lombok.ToString;
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties;
|
||||
import org.springframework.boot.convert.DurationUnit;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
@ToString
|
||||
@EqualsAndHashCode
|
||||
@AllArgsConstructor
|
||||
@NoArgsConstructor
|
||||
@ConfigurationProperties(prefix = "resttemplate.timeout")
|
||||
@Component
|
||||
public class RestTemplateTimeoutProperties {
|
||||
|
||||
@DurationUnit(ChronoUnit.MILLIS)
|
||||
private Duration readTimeoutRestHealthIndicatorInMillis;
|
||||
@DurationUnit(ChronoUnit.MILLIS)
|
||||
private Duration connectionRestHealthIndicatorTimeoutInMillis;
|
||||
@DurationUnit(ChronoUnit.MILLIS)
|
||||
private Duration readTimeoutRestTemplateInMillis;
|
||||
@DurationUnit(ChronoUnit.MILLIS)
|
||||
private Duration connectionRestTemplateTimeoutInMillis;
|
||||
}
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
package de.twomartens.template.property;
|
||||
|
||||
import io.swagger.v3.oas.annotations.media.Schema;
|
||||
import java.time.ZoneId;
|
||||
import lombok.Data;
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties;
|
||||
import org.springframework.cloud.context.config.annotation.RefreshScope;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Data
|
||||
@RefreshScope
|
||||
@Configuration
|
||||
@ConfigurationProperties(prefix = "de.twomartens.template")
|
||||
@Schema(description = "Properties, to configure this Application")
|
||||
public class ServiceProperties {
|
||||
|
||||
private ZoneId defaultTimeZone;
|
||||
|
||||
private String greeting;
|
||||
|
||||
}
|
||||
-28
@@ -1,28 +0,0 @@
|
||||
package de.twomartens.template.property;
|
||||
|
||||
import io.swagger.v3.oas.annotations.media.Schema;
|
||||
import java.time.Duration;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import lombok.Data;
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties;
|
||||
import org.springframework.boot.convert.DurationUnit;
|
||||
import org.springframework.cloud.context.config.annotation.RefreshScope;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Data
|
||||
@RefreshScope
|
||||
@Configuration
|
||||
@ConfigurationProperties(prefix = "de.twomartens.template.statusprobe")
|
||||
@Schema(description = "Properties, to configure this Application")
|
||||
public class StatusProbeProperties {
|
||||
|
||||
@DurationUnit(ChronoUnit.SECONDS)
|
||||
private Duration scheduleDuration;
|
||||
|
||||
@DurationUnit(ChronoUnit.MINUTES)
|
||||
private Duration maxKafkaFailureDuration;
|
||||
|
||||
private int maxBlobFailureCount;
|
||||
|
||||
private int maxFailurePercent;
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
package de.twomartens.template.repository;
|
||||
|
||||
import de.twomartens.template.model.db.Greeting;
|
||||
import java.util.Optional;
|
||||
import org.springframework.data.mongodb.repository.MongoRepository;
|
||||
|
||||
public interface GreetingRepository extends MongoRepository<Greeting, String> {
|
||||
|
||||
Optional<Greeting> findByMessageIgnoreCase(String message);
|
||||
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
package de.twomartens.template.service;
|
||||
|
||||
import de.twomartens.template.model.db.Greeting;
|
||||
import de.twomartens.template.property.ServiceProperties;
|
||||
import de.twomartens.template.repository.GreetingRepository;
|
||||
import io.micrometer.core.instrument.Counter;
|
||||
import io.micrometer.core.instrument.MeterRegistry;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
@Slf4j
|
||||
@Service
|
||||
public class GreetingService {
|
||||
|
||||
private final MeterRegistry meterRegistry;
|
||||
private final ServiceProperties serviceProperties;
|
||||
private final Counter counter;
|
||||
|
||||
private final GreetingRepository greetingRepository;
|
||||
|
||||
public GreetingService(MeterRegistry meterRegistry, ServiceProperties serviceProperties,
|
||||
GreetingRepository greetingRepository) {
|
||||
this.meterRegistry = meterRegistry;
|
||||
this.serviceProperties = serviceProperties;
|
||||
this.greetingRepository = greetingRepository;
|
||||
counter = meterRegistry.counter("template.callCounter");
|
||||
}
|
||||
|
||||
public Greeting createGreeting(String name) {
|
||||
log.info("Create greeting for '{}'", name);
|
||||
counter.increment();
|
||||
meterRegistry.gauge("template.nameLength", name.length());
|
||||
String greeting = serviceProperties.getGreeting();
|
||||
return Greeting.builder().message(String.format(greeting, name)).build();
|
||||
}
|
||||
|
||||
public void postGreeting(Greeting greeting) {
|
||||
greetingRepository.save(greeting);
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
package de.twomartens.template.service;
|
||||
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.log4j.Log4j2;
|
||||
import org.apache.logging.log4j.message.StringMapMessage;
|
||||
import org.springframework.cloud.context.refresh.ContextRefresher;
|
||||
import org.springframework.scheduling.annotation.Scheduled;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
/**
|
||||
* automatically reloads application*.yaml. reload can also be triggered manually by doing a post
|
||||
* request on http://localhost:12001/actuator/refresh
|
||||
*/
|
||||
@Log4j2
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
public class PropertyReloadService {
|
||||
|
||||
public static final int REFRESH_SECONDS = 60;
|
||||
public static final String PARAM_MESSAGE = "message";
|
||||
public static final String PARAM_PROPERTIES = "labels.properties";
|
||||
|
||||
private final ContextRefresher contextRefresher;
|
||||
|
||||
@Scheduled(fixedDelay = REFRESH_SECONDS, initialDelay = REFRESH_SECONDS, timeUnit = TimeUnit.SECONDS)
|
||||
public void refresh() {
|
||||
Set<String> properties = contextRefresher.refresh();
|
||||
if (!properties.isEmpty()) {
|
||||
log.info(new StringMapMessage()
|
||||
.with(PARAM_MESSAGE, "properties changed")
|
||||
.with(PARAM_PROPERTIES, String.join("\n", properties)));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package de.twomartens.timetable
|
||||
|
||||
import de.twomartens.timetable.bahnApi.service.BahnApiService
|
||||
import mu.KotlinLogging
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication
|
||||
import org.springframework.boot.context.event.ApplicationReadyEvent
|
||||
import org.springframework.boot.runApplication
|
||||
import org.springframework.context.event.EventListener
|
||||
import org.springframework.data.mongodb.config.EnableMongoAuditing
|
||||
import org.springframework.scheduling.annotation.EnableScheduling
|
||||
import java.time.LocalDate
|
||||
import java.time.LocalTime
|
||||
import java.time.Month
|
||||
|
||||
@EnableMongoAuditing
|
||||
@EnableScheduling
|
||||
@SpringBootApplication
|
||||
open class MainApplication(
|
||||
private val bahnApiService: BahnApiService
|
||||
) {
|
||||
@EventListener(ApplicationReadyEvent::class)
|
||||
fun ready() {
|
||||
val result = bahnApiService.fetchStations("Köln Hbf")
|
||||
val koeln = result[0]
|
||||
val stops = bahnApiService.fetchTimetable(koeln.eva,
|
||||
LocalDate.of(2023, Month.SEPTEMBER, 23),
|
||||
LocalTime.of(17, 0))
|
||||
log.info("stations: $result")
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val log = KotlinLogging.logger {}
|
||||
}
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
runApplication<MainApplication>(*args)
|
||||
}
|
||||
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
package de.twomartens.timetable.configuration
|
||||
|
||||
import de.twomartens.timetable.bahnApi.property.BahnApiProperties
|
||||
import de.twomartens.timetable.property.RestTemplateTimeoutProperties
|
||||
import de.twomartens.timetable.property.ServiceProperties
|
||||
import de.twomartens.timetable.property.StatusProbeProperties
|
||||
import de.twomartens.timetable.property.TimeProperties
|
||||
import org.springframework.boot.context.properties.EnableConfigurationProperties
|
||||
import org.springframework.context.annotation.Configuration
|
||||
|
||||
@Configuration
|
||||
@EnableConfigurationProperties(RestTemplateTimeoutProperties::class, ServiceProperties::class,
|
||||
StatusProbeProperties::class, TimeProperties::class, BahnApiProperties::class)
|
||||
open class PropertyConfiguration
|
||||
@@ -0,0 +1,12 @@
|
||||
package de.twomartens.timetable.property
|
||||
|
||||
import io.swagger.v3.oas.annotations.media.Schema
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties
|
||||
import org.springframework.cloud.context.config.annotation.RefreshScope
|
||||
|
||||
@RefreshScope
|
||||
@ConfigurationProperties(prefix = "de.twomartens.timetable")
|
||||
@Schema(description = "Properties, to configure this Application")
|
||||
class ServiceProperties {
|
||||
lateinit var greeting: String
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import de.twomartens.timetable.property.TimeProperties
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import java.time.Clock
|
||||
|
||||
@Configuration
|
||||
open class ClockConfiguration(private val properties: TimeProperties) {
|
||||
|
||||
@Bean
|
||||
open fun clock(): Clock {
|
||||
return Clock.system(properties.defaultTimeZone)
|
||||
}
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.web.filter.ForwardedHeaderFilter
|
||||
|
||||
@Configuration
|
||||
open class FilterConfiguration {
|
||||
@Bean
|
||||
open fun forwardedFilter(): ForwardedHeaderFilter {
|
||||
return ForwardedHeaderFilter()
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import de.twomartens.timetable.support.interceptor.HeaderInterceptorRest
|
||||
import de.twomartens.timetable.support.interceptor.LoggingInterceptorRest
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import java.time.Clock
|
||||
|
||||
@Configuration
|
||||
open class InterceptorConfiguration {
|
||||
@Bean
|
||||
open fun loggingInterceptorRest(clock: Clock): LoggingInterceptorRest {
|
||||
return LoggingInterceptorRest(clock)
|
||||
}
|
||||
|
||||
@Bean
|
||||
open fun headerInterceptorRest(): HeaderInterceptorRest {
|
||||
return HeaderInterceptorRest()
|
||||
}
|
||||
}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import io.swagger.v3.oas.annotations.enums.SecuritySchemeType
|
||||
import io.swagger.v3.oas.annotations.security.OAuthFlow
|
||||
import io.swagger.v3.oas.annotations.security.OAuthFlows
|
||||
import io.swagger.v3.oas.annotations.security.SecurityScheme
|
||||
import io.swagger.v3.oas.models.OpenAPI
|
||||
import io.swagger.v3.oas.models.info.Info
|
||||
import org.springframework.beans.factory.annotation.Value
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
|
||||
@SecurityScheme(name = "bearerAuth", type = SecuritySchemeType.HTTP, scheme = "bearer", bearerFormat = "JWT")
|
||||
@SecurityScheme(
|
||||
name = "oauth2",
|
||||
type = SecuritySchemeType.OAUTH2,
|
||||
flows = OAuthFlows(
|
||||
implicit = OAuthFlow(
|
||||
authorizationUrl = "https://id.2martens.de/realms/2martens/protocol/openid-connect/auth",
|
||||
tokenUrl = "https://id.2martens.de/realms/2martens/protocol/openid-connect/token"
|
||||
)
|
||||
)
|
||||
)
|
||||
@Configuration
|
||||
open class OpenApiConfiguration {
|
||||
@Bean
|
||||
open fun customOpenAPI(
|
||||
@Value("\${openapi.description}") apiDescription: String,
|
||||
@Value("\${openapi.version}") apiVersion: String, @Value("\${openapi.title}") apiTitle: String
|
||||
): OpenAPI {
|
||||
return OpenAPI()
|
||||
.info(
|
||||
Info()
|
||||
.title(apiTitle)
|
||||
.version(apiVersion)
|
||||
.description(apiDescription)
|
||||
)
|
||||
}
|
||||
}
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import de.twomartens.timetable.support.interceptor.HeaderInterceptorRest
|
||||
import de.twomartens.timetable.support.interceptor.LoggingInterceptorRest
|
||||
import de.twomartens.timetable.property.RestTemplateTimeoutProperties
|
||||
import org.springframework.boot.web.client.RestTemplateBuilder
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.web.client.RestTemplate
|
||||
|
||||
@Configuration
|
||||
open class RestTemplateConfiguration {
|
||||
@Bean("restTemplate")
|
||||
open fun restTemplate(
|
||||
headerInterceptorRest: HeaderInterceptorRest,
|
||||
loggingInterceptor: LoggingInterceptorRest,
|
||||
restTemplateTimeoutProperties: RestTemplateTimeoutProperties
|
||||
): RestTemplate {
|
||||
return RestTemplateBuilder()
|
||||
.additionalInterceptors(headerInterceptorRest, loggingInterceptor)
|
||||
.setConnectTimeout(restTemplateTimeoutProperties.connectionRestTemplateTimeoutInMillis)
|
||||
.setReadTimeout(restTemplateTimeoutProperties.readTimeoutRestTemplateInMillis)
|
||||
.build()
|
||||
}
|
||||
|
||||
@Bean("restTemplateRestHealthIndicator")
|
||||
open fun restTemplateRestHealthIndicator(
|
||||
headerInterceptorRest: HeaderInterceptorRest,
|
||||
restTemplateTimeoutProperties: RestTemplateTimeoutProperties
|
||||
): RestTemplate {
|
||||
return RestTemplateBuilder()
|
||||
.additionalInterceptors(headerInterceptorRest)
|
||||
.setConnectTimeout(restTemplateTimeoutProperties.connectionRestHealthIndicatorTimeoutInMillis)
|
||||
.setReadTimeout(restTemplateTimeoutProperties.readTimeoutRestHealthIndicatorInMillis)
|
||||
.build()
|
||||
}
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import de.twomartens.timetable.support.monitoring.statusprobe.CountBasedStatusProbe
|
||||
import de.twomartens.timetable.support.monitoring.statusprobe.StatusProbe
|
||||
import de.twomartens.timetable.support.monitoring.statusprobe.StatusProbeCriticality
|
||||
import de.twomartens.timetable.support.monitoring.statusprobe.StatusProbeLogger
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import java.time.Clock
|
||||
|
||||
@Configuration
|
||||
open class StatusProbeConfiguration(private val clock: Clock) {
|
||||
@Bean
|
||||
open fun statusProbeLogger(): StatusProbeLogger {
|
||||
return StatusProbeLogger(clock)
|
||||
}
|
||||
|
||||
@Bean
|
||||
open fun testStatusProbe(statusProbeLogger: StatusProbeLogger): StatusProbe {
|
||||
return CountBasedStatusProbe(
|
||||
1,
|
||||
clock, StatusProbeCriticality.K1, "testStatusProbe", statusProbeLogger
|
||||
)
|
||||
}
|
||||
}
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import de.twomartens.timetable.support.interceptor.HeaderInterceptorRest
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.http.HttpMethod
|
||||
import org.springframework.web.servlet.config.annotation.CorsRegistry
|
||||
import org.springframework.web.servlet.config.annotation.InterceptorRegistry
|
||||
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
|
||||
|
||||
@Configuration
|
||||
open class WebConfiguration(private val headerInterceptorRest: HeaderInterceptorRest) : WebMvcConfigurer {
|
||||
override fun addInterceptors(registry: InterceptorRegistry) {
|
||||
registry.addInterceptor(headerInterceptorRest)
|
||||
}
|
||||
|
||||
override fun addCorsMappings(registry: CorsRegistry) {
|
||||
val registration = registry.addMapping("/**")
|
||||
registration.allowedMethods(
|
||||
HttpMethod.GET.name(), HttpMethod.POST.name(),
|
||||
HttpMethod.PUT.name(), HttpMethod.HEAD.name()
|
||||
)
|
||||
registration.allowCredentials(true)
|
||||
registration.allowedOrigins(
|
||||
"http://localhost:4200",
|
||||
"https://timetable.2martens.de"
|
||||
)
|
||||
}
|
||||
}
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
package de.twomartens.timetable.support.configuration
|
||||
|
||||
import de.twomartens.timetable.support.security.SpringPolicyEnforcerFilter
|
||||
import org.keycloak.adapters.authorization.spi.ConfigurationResolver
|
||||
import org.keycloak.adapters.authorization.spi.HttpRequest
|
||||
import org.keycloak.representations.adapters.config.PolicyEnforcerConfig
|
||||
import org.keycloak.representations.adapters.config.PolicyEnforcerConfig.EnforcementMode
|
||||
import org.keycloak.representations.adapters.config.PolicyEnforcerConfig.PathConfig
|
||||
import org.keycloak.util.JsonSerialization
|
||||
import org.springframework.beans.factory.annotation.Value
|
||||
import org.springframework.context.annotation.Bean
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.http.HttpMethod
|
||||
import org.springframework.security.config.Customizer
|
||||
import org.springframework.security.config.annotation.web.builders.HttpSecurity
|
||||
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
|
||||
import org.springframework.security.config.annotation.web.configurers.oauth2.server.resource.OAuth2ResourceServerConfigurer
|
||||
import org.springframework.security.oauth2.jwt.JwtDecoder
|
||||
import org.springframework.security.oauth2.jwt.NimbusJwtDecoder
|
||||
import org.springframework.security.oauth2.server.resource.web.authentication.BearerTokenAuthenticationFilter
|
||||
import org.springframework.security.web.SecurityFilterChain
|
||||
import java.io.IOException
|
||||
|
||||
@Configuration
|
||||
@EnableWebSecurity
|
||||
open class WebSecurityConfiguration {
|
||||
@Value("\${spring.security.oauth2.resourceserver.jwt.jwk-set-uri}")
|
||||
private lateinit var jwkSetUri: String
|
||||
|
||||
@Value("#{environment.CLIENT_SECRET}")
|
||||
private lateinit var clientSecret: String
|
||||
|
||||
@Bean
|
||||
@Throws(Exception::class)
|
||||
open fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {
|
||||
http
|
||||
.csrf { it.disable() }
|
||||
.authorizeHttpRequests { it.requestMatchers(*PERMITTED_PATHS.toTypedArray<String>()).permitAll() }
|
||||
.authorizeHttpRequests { it.requestMatchers(HttpMethod.OPTIONS).permitAll() }
|
||||
.authorizeHttpRequests { it.anyRequest().authenticated() }
|
||||
.oauth2ResourceServer { obj: OAuth2ResourceServerConfigurer<HttpSecurity?> -> obj.jwt(Customizer.withDefaults()) }
|
||||
.addFilterAfter(createPolicyEnforcerFilter(), BearerTokenAuthenticationFilter::class.java)
|
||||
return http.build()
|
||||
}
|
||||
|
||||
@Bean
|
||||
open fun jwtDecoder(): JwtDecoder {
|
||||
return NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build()
|
||||
}
|
||||
|
||||
private fun createPolicyEnforcerFilter(): SpringPolicyEnforcerFilter {
|
||||
return SpringPolicyEnforcerFilter(object : ConfigurationResolver {
|
||||
override fun resolve(request: HttpRequest): PolicyEnforcerConfig {
|
||||
return try {
|
||||
val policyEnforcerConfig = JsonSerialization.readValue(
|
||||
javaClass.getResourceAsStream("/policy-enforcer.json"), PolicyEnforcerConfig::class.java
|
||||
)
|
||||
policyEnforcerConfig.credentials = mapOf(Pair("secret", clientSecret))
|
||||
if (request.method == HttpMethod.OPTIONS.name()) {
|
||||
// always allow options request
|
||||
policyEnforcerConfig.enforcementMode = EnforcementMode.DISABLED
|
||||
} else {
|
||||
policyEnforcerConfig.paths = PATHS
|
||||
}
|
||||
policyEnforcerConfig
|
||||
} catch (e: IOException) {
|
||||
throw RuntimeException(e)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val PERMITTED_PATHS: Collection<String> = listOf(
|
||||
"/timetable/v1/healthCheck",
|
||||
"/actuator/**",
|
||||
"/timetable/v1/doc/**",
|
||||
"/timetable/v1/api-docs/**",
|
||||
"/error",
|
||||
"/timetable/version",
|
||||
)
|
||||
private val PATHS = buildPathConfigs()
|
||||
|
||||
private fun buildPathConfigs(): List<PathConfig> {
|
||||
val paths: MutableList<PathConfig> = mutableListOf()
|
||||
for (path in PERMITTED_PATHS) {
|
||||
val pathConfig = PathConfig()
|
||||
pathConfig.path = path.replace("**", "*")
|
||||
pathConfig.enforcementMode = EnforcementMode.DISABLED
|
||||
paths.add(pathConfig)
|
||||
}
|
||||
return paths
|
||||
}
|
||||
}
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
package de.twomartens.timetable.support.controller
|
||||
|
||||
import de.twomartens.timetable.support.exception.HttpStatusException
|
||||
import de.twomartens.timetable.support.model.dto.ErrorMessage
|
||||
import mu.KotlinLogging
|
||||
import org.springframework.http.HttpStatus
|
||||
import org.springframework.http.ResponseEntity
|
||||
import org.springframework.web.bind.annotation.ControllerAdvice
|
||||
import org.springframework.web.bind.annotation.ExceptionHandler
|
||||
import org.springframework.web.bind.annotation.RestController
|
||||
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler
|
||||
|
||||
@ControllerAdvice(annotations = [RestController::class])
|
||||
class ExceptionController: ResponseEntityExceptionHandler() {
|
||||
@ExceptionHandler(HttpStatusException::class)
|
||||
fun handleException(e: HttpStatusException): ResponseEntity<ErrorMessage> {
|
||||
if (e.cause != null) {
|
||||
log.info(e.cause.toString(), e.cause)
|
||||
} else {
|
||||
log.info(e.toString())
|
||||
}
|
||||
return ResponseEntity.status(e.status)
|
||||
.body(ErrorMessage(e.message!!))
|
||||
}
|
||||
|
||||
@ExceptionHandler(RuntimeException::class)
|
||||
fun handleRuntimeException(e: RuntimeException): ResponseEntity<ErrorMessage> {
|
||||
log.error("unexpected exception occurred", e)
|
||||
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
|
||||
.body(ErrorMessage(message = e.message!!))
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val log = KotlinLogging.logger {}
|
||||
}
|
||||
}
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
package de.twomartens.timetable.support.controller
|
||||
|
||||
import mu.KotlinLogging
|
||||
import org.springframework.stereotype.Controller
|
||||
import org.springframework.web.bind.annotation.GetMapping
|
||||
import org.springframework.web.bind.annotation.ModelAttribute
|
||||
import org.springframework.web.bind.annotation.RequestHeader
|
||||
import org.springframework.web.bind.annotation.RequestMapping
|
||||
import java.io.FileNotFoundException
|
||||
import java.net.InetAddress
|
||||
import java.net.UnknownHostException
|
||||
import java.nio.charset.StandardCharsets
|
||||
import java.nio.file.Paths
|
||||
import java.util.jar.JarFile
|
||||
|
||||
@Controller
|
||||
@RequestMapping(value = ["/timetable"])
|
||||
class VersionHtmlController {
|
||||
@GetMapping(path = ["/version"])
|
||||
fun version(): String {
|
||||
return "version"
|
||||
}
|
||||
|
||||
@ModelAttribute("version")
|
||||
private fun getApplicationVersion(): String {
|
||||
return "${getTitle()} ${getVersion()}"
|
||||
}
|
||||
|
||||
@ModelAttribute("footerString")
|
||||
private fun getApplicationVersion(@RequestHeader("host") hostName: String): String {
|
||||
return "${getTitle()} ${getVersion()} - $hostName"
|
||||
}
|
||||
|
||||
private fun getTitle(): String {
|
||||
val title = VersionHtmlController::class.java.`package`.implementationTitle
|
||||
?: return "application"
|
||||
return title.ifBlank {
|
||||
"application"
|
||||
}
|
||||
}
|
||||
|
||||
private fun getVersion(): String {
|
||||
val version = VersionHtmlController::class.java.`package`.implementationVersion
|
||||
?: return "DEVELOPER"
|
||||
return version.ifBlank {
|
||||
"DEVELOPER"
|
||||
}
|
||||
}
|
||||
|
||||
@ModelAttribute("hostname")
|
||||
private fun getHostname(): String {
|
||||
try {
|
||||
return InetAddress.getLocalHost().hostName
|
||||
} catch (e: UnknownHostException) {
|
||||
log.warn(e.toString(), e)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
@ModelAttribute("manifest")
|
||||
private fun getManifest(): Collection<String> {
|
||||
try {
|
||||
val location = javaClass.getProtectionDomain().codeSource.location
|
||||
val jarFileName = Paths.get(location.toURI()).toString()
|
||||
JarFile(jarFileName).use { jarFile ->
|
||||
val entry = jarFile.getEntry(JarFile.MANIFEST_NAME)
|
||||
jarFile.getInputStream(entry).use { `in` ->
|
||||
return String(`in`.readAllBytes(), StandardCharsets.UTF_8).lines().toList() }
|
||||
}
|
||||
} catch (ignored: FileNotFoundException) {
|
||||
// do nothing if manifest file is not available
|
||||
} catch (e: Exception) {
|
||||
log.info(e.toString(), e)
|
||||
}
|
||||
return listOf("${getTitle()} ${getVersion()}")
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val log = KotlinLogging.logger {}
|
||||
}
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
package de.twomartens.timetable.support.exception
|
||||
|
||||
import org.springframework.http.HttpStatus
|
||||
|
||||
class HttpStatusException(val status: HttpStatus, message: String, cause: Throwable?):
|
||||
RuntimeException(message, cause)
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
package de.twomartens.timetable.support.interceptor
|
||||
|
||||
import org.springframework.http.HttpHeaders
|
||||
import org.springframework.http.HttpStatusCode
|
||||
import org.springframework.http.client.ClientHttpResponse
|
||||
import org.springframework.util.StreamUtils
|
||||
import java.io.ByteArrayInputStream
|
||||
import java.io.IOException
|
||||
import java.io.InputStream
|
||||
|
||||
class BufferingClientHttpResponseWrapper(private val response: ClientHttpResponse): ClientHttpResponse {
|
||||
private var body: ByteArray? = null
|
||||
|
||||
@Throws(IOException::class)
|
||||
override fun getStatusCode(): HttpStatusCode {
|
||||
return response.statusCode
|
||||
}
|
||||
|
||||
@Deprecated("Replace calls of getRawStatusCode with getStatusCode", ReplaceWith("getStatusCode()"))
|
||||
@Throws(IOException::class)
|
||||
override fun getRawStatusCode(): Int {
|
||||
return statusCode.value()
|
||||
}
|
||||
|
||||
@Throws(IOException::class)
|
||||
override fun getStatusText(): String {
|
||||
return response.statusText
|
||||
}
|
||||
|
||||
override fun getHeaders(): HttpHeaders {
|
||||
return response.headers
|
||||
}
|
||||
|
||||
@Throws(IOException::class)
|
||||
override fun getBody(): InputStream {
|
||||
if (body == null) {
|
||||
body = StreamUtils.copyToByteArray(response.body)
|
||||
}
|
||||
return ByteArrayInputStream(body)
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
response.close()
|
||||
}
|
||||
}
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
package de.twomartens.timetable.support.interceptor
|
||||
|
||||
import org.slf4j.MDC
|
||||
import java.io.Closeable
|
||||
import java.util.*
|
||||
|
||||
abstract class HeaderInterceptor {
|
||||
companion object {
|
||||
const val LOGGER_TRACE_ID = "trace.id"
|
||||
const val LOGGER_REQTYPE_ID = "REQTYPE"
|
||||
|
||||
const val HEADER_FIELD_TRACE_ID = "X-TraceId"
|
||||
const val HEADER_FIELD_B3_TRACE_ID = "x-b3-traceid"
|
||||
const val HEADER_FIELD_TYPE_ID = "x-type"
|
||||
|
||||
const val REQ_TYPE_HEALTHCHECK = "HEALTH_CHECK"
|
||||
const val REQ_TYPE_INTEGRATION_TEST = "INTEGRATION_TEST"
|
||||
const val REQ_TYPE_SERVER_TEST = "SERVER_TEST"
|
||||
const val REQ_TYPE_WARMUP = "WARMUP"
|
||||
|
||||
fun createNewTraceId(): String {
|
||||
return UUID.randomUUID().toString()
|
||||
}
|
||||
|
||||
fun getTraceId(): String {
|
||||
val traceId = MDC.get(LOGGER_TRACE_ID)
|
||||
return if (traceId.isNullOrBlank()) createNewTraceId() else traceId
|
||||
}
|
||||
|
||||
fun getRequestType(): String? {
|
||||
val type = MDC.get(LOGGER_REQTYPE_ID)
|
||||
return if (type.isNullOrBlank()) null else type
|
||||
}
|
||||
|
||||
private fun setTraceId(traceId: String): InterceptorCloseables {
|
||||
return InterceptorCloseables(MDC.putCloseable(LOGGER_TRACE_ID, traceId))
|
||||
}
|
||||
|
||||
private fun mark(requestType: String?): InterceptorCloseables {
|
||||
return InterceptorCloseables(MDC.putCloseable(LOGGER_REQTYPE_ID, requestType))
|
||||
}
|
||||
|
||||
fun set(traceId: String, requestType: String?): InterceptorCloseables {
|
||||
return if (requestType != null) {
|
||||
InterceptorCloseables(setTraceId(traceId), mark(requestType))
|
||||
} else setTraceId(traceId)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fun markAsHealthCheck(): InterceptorCloseables {
|
||||
return InterceptorCloseables(mark(REQ_TYPE_HEALTHCHECK), setTraceId(createNewTraceId()))
|
||||
}
|
||||
|
||||
fun markAsIntegrationTest(): InterceptorCloseables {
|
||||
return InterceptorCloseables(mark(REQ_TYPE_INTEGRATION_TEST), setTraceId(createNewTraceId()))
|
||||
}
|
||||
|
||||
fun markAsServerTest(): InterceptorCloseables {
|
||||
return InterceptorCloseables(mark(REQ_TYPE_SERVER_TEST), setTraceId(createNewTraceId()))
|
||||
}
|
||||
|
||||
fun markAsWarmup(): InterceptorCloseables {
|
||||
return InterceptorCloseables(mark(REQ_TYPE_WARMUP), setTraceId(createNewTraceId()))
|
||||
}
|
||||
|
||||
class InterceptorCloseables(vararg closeables: Closeable) : Closeable {
|
||||
private val closeables: Array<out Closeable>
|
||||
|
||||
init {
|
||||
this.closeables = closeables
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
closeables.forEach {
|
||||
try {
|
||||
it.close()
|
||||
} catch (ignored: Exception) {
|
||||
// do nothing
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
+88
@@ -0,0 +1,88 @@
|
||||
package de.twomartens.timetable.support.interceptor
|
||||
|
||||
import jakarta.servlet.http.HttpServletRequest
|
||||
import jakarta.servlet.http.HttpServletResponse
|
||||
import org.springframework.http.HttpRequest
|
||||
import org.springframework.http.client.ClientHttpRequestExecution
|
||||
import org.springframework.http.client.ClientHttpRequestInterceptor
|
||||
import org.springframework.http.client.ClientHttpResponse
|
||||
import org.springframework.web.servlet.HandlerInterceptor
|
||||
import java.io.IOException
|
||||
import java.util.*
|
||||
|
||||
class HeaderInterceptorRest : HeaderInterceptor(), HandlerInterceptor, ClientHttpRequestInterceptor {
|
||||
companion object {
|
||||
val CLASS_NAME: String = HeaderInterceptorRest::class.java.getName()
|
||||
|
||||
fun extractTraceId(request: HttpServletRequest): String {
|
||||
var traceId = request.getHeader(HEADER_FIELD_TRACE_ID)
|
||||
if (traceId.isNullOrBlank()) traceId = request.getHeader(HEADER_FIELD_B3_TRACE_ID)
|
||||
if (traceId.isNullOrBlank()) return createNewTraceId()
|
||||
return traceId
|
||||
}
|
||||
|
||||
fun extractTraceId(request: HttpRequest): String {
|
||||
var traceId = request.headers[HEADER_FIELD_TRACE_ID]?.first()
|
||||
if (traceId.isNullOrBlank()) traceId = request.headers[HEADER_FIELD_B3_TRACE_ID]?.first()
|
||||
if (traceId.isNullOrBlank()) return UUID.randomUUID().toString()
|
||||
return traceId
|
||||
}
|
||||
|
||||
fun extractRequestType(request: HttpServletRequest): String? {
|
||||
val type = request.getHeader(HEADER_FIELD_TYPE_ID)
|
||||
if (type.isNullOrBlank()) return null
|
||||
return type
|
||||
}
|
||||
|
||||
fun extractRequestType(request: HttpRequest): String? {
|
||||
val type = request.headers[HEADER_FIELD_TYPE_ID]?.first()
|
||||
if (type.isNullOrBlank()) return null
|
||||
return type
|
||||
}
|
||||
}
|
||||
|
||||
// ClientHttpRequestInterceptor
|
||||
@Throws(IOException::class)
|
||||
override fun intercept(
|
||||
request: HttpRequest, body: ByteArray,
|
||||
execution: ClientHttpRequestExecution
|
||||
): ClientHttpResponse {
|
||||
request.headers.add(HEADER_FIELD_TRACE_ID, getTraceId())
|
||||
val requestType = getRequestType()
|
||||
if (requestType != null) {
|
||||
request.headers.add(HEADER_FIELD_TYPE_ID, requestType)
|
||||
}
|
||||
|
||||
return try {
|
||||
execution.execute(request, body)
|
||||
} finally {
|
||||
request.headers.remove(HEADER_FIELD_TRACE_ID)
|
||||
request.headers.remove(HEADER_FIELD_TYPE_ID)
|
||||
}
|
||||
}
|
||||
|
||||
// HandlerInterceptor
|
||||
override fun preHandle(
|
||||
request: HttpServletRequest, response: HttpServletResponse,
|
||||
handler: Any
|
||||
): Boolean {
|
||||
val traceId = extractTraceId(request)
|
||||
val requestType = extractRequestType(request)
|
||||
val closeable = set(traceId, requestType)
|
||||
request.setAttribute(CLASS_NAME, closeable)
|
||||
return true
|
||||
}
|
||||
|
||||
// HandlerInterceptor
|
||||
// override fun postHandle(
|
||||
// request: HttpServletRequest,
|
||||
// response: HttpServletResponse,
|
||||
// handler: Any,
|
||||
// modelAndView: ModelAndView?
|
||||
// ) {
|
||||
// val obj = request.getAttribute(CLASS_NAME)
|
||||
// if (obj != null && obj is InterceptorCloseables) {
|
||||
// obj.close()
|
||||
// }
|
||||
// }
|
||||
}
|
||||
+438
@@ -0,0 +1,438 @@
|
||||
package de.twomartens.timetable.support.interceptor
|
||||
|
||||
import jakarta.servlet.*
|
||||
import jakarta.servlet.http.HttpServletRequest
|
||||
import jakarta.servlet.http.HttpServletResponse
|
||||
import mu.KotlinLogging
|
||||
import org.apache.logging.log4j.message.StringMapMessage
|
||||
import org.slf4j.Marker
|
||||
import org.slf4j.MarkerFactory
|
||||
import org.springframework.http.*
|
||||
import org.springframework.http.client.ClientHttpRequestExecution
|
||||
import org.springframework.http.client.ClientHttpRequestInterceptor
|
||||
import org.springframework.http.client.ClientHttpResponse
|
||||
import org.springframework.util.StreamUtils
|
||||
import org.springframework.web.util.ContentCachingRequestWrapper
|
||||
import org.springframework.web.util.ContentCachingResponseWrapper
|
||||
import java.io.IOException
|
||||
import java.net.URL
|
||||
import java.nio.charset.Charset
|
||||
import java.nio.charset.StandardCharsets
|
||||
import java.time.Clock
|
||||
import java.time.Duration
|
||||
import java.time.ZonedDateTime
|
||||
import java.time.format.DateTimeFormatter
|
||||
import java.util.*
|
||||
import java.util.function.Function
|
||||
|
||||
class LoggingInterceptorRest(
|
||||
private val requestLogBehaviour: FieldLogBehaviour,
|
||||
private val responseLogBehaviour: FieldLogBehaviour,
|
||||
val clock: Clock
|
||||
) : Filter, ClientHttpRequestInterceptor {
|
||||
|
||||
constructor(clock: Clock) : this(FieldLogBehaviour.NEVER, FieldLogBehaviour.NEVER, clock)
|
||||
|
||||
@Throws(IOException::class, ServletException::class)
|
||||
override fun doFilter(
|
||||
request: ServletRequest, response: ServletResponse,
|
||||
chain: FilterChain
|
||||
) {
|
||||
val requestTime = ZonedDateTime.now(clock)
|
||||
val httpRequest = request as HttpServletRequest
|
||||
val requestWrapper = ContentCachingRequestWrapper(httpRequest)
|
||||
val responseWrapper = ContentCachingResponseWrapper(
|
||||
(response as HttpServletResponse)
|
||||
)
|
||||
var fullResponseBytes: ByteArray? = null
|
||||
var throwable: Throwable? = null
|
||||
var responseBody: String? = null
|
||||
var httpStatusCode = -1
|
||||
try {
|
||||
try {
|
||||
chain.doFilter(
|
||||
if (requestLogBehaviour != FieldLogBehaviour.NEVER) requestWrapper else httpRequest,
|
||||
responseWrapper
|
||||
)
|
||||
if (responseLogBehaviour != FieldLogBehaviour.NEVER) {
|
||||
fullResponseBytes = responseWrapper.contentAsByteArray
|
||||
}
|
||||
httpStatusCode = responseWrapper.status
|
||||
} finally {
|
||||
responseWrapper.copyBodyToResponse()
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
throwable = e
|
||||
throw e
|
||||
} finally {
|
||||
try {
|
||||
val responseSize = responseWrapper.contentSize
|
||||
val responseHeaders = extractHeaders(
|
||||
headerNames = responseWrapper.headerNames.iterator()
|
||||
) { responseWrapper.getHeaders(it).iterator() }
|
||||
if (
|
||||
(responseLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| responseLogBehaviour == FieldLogBehaviour.ALWAYS)
|
||||
&& fullResponseBytes != null
|
||||
) {
|
||||
responseBody = String(
|
||||
fullResponseBytes,
|
||||
determineResponseEncoding()
|
||||
)
|
||||
}
|
||||
val query = if (httpRequest.queryString != null) "?${httpRequest.queryString}" else ""
|
||||
val requestUrl = URL("${httpRequest.requestURL}$query")
|
||||
val requestHeaders = extractHeaders(
|
||||
headerNames = httpRequest.headerNames.asIterator(),
|
||||
ignoreList = listOf("authorization")) {
|
||||
httpRequest.getHeaders(it).asIterator()
|
||||
}
|
||||
var requestBody: String? = null
|
||||
var businessType: String? = null
|
||||
if (requestLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| requestLogBehaviour == FieldLogBehaviour.ALWAYS
|
||||
) {
|
||||
val fullRequestBytes = requestWrapper.contentAsByteArray
|
||||
requestBody = String(fullRequestBytes, determineRequestEncoding())
|
||||
businessType = determineBusinessType()
|
||||
}
|
||||
log(
|
||||
LogMessage(
|
||||
requestHeaders = requestHeaders,
|
||||
responseHeaders = responseHeaders,
|
||||
url = requestUrl,
|
||||
method = httpRequest.method,
|
||||
requestMimeType = typeToString(request.getContentType()),
|
||||
responseMimeType = typeToString(response.getContentType()),
|
||||
requestBody = requestBody,
|
||||
responseBody = responseBody,
|
||||
requestSize = httpRequest.contentLength,
|
||||
responseSize = responseSize,
|
||||
httpStatus = httpStatusCode,
|
||||
direction = DIRECTION_IN,
|
||||
requestTime = requestTime,
|
||||
responseTime = ZonedDateTime.now(clock),
|
||||
traceId = HeaderInterceptor.getTraceId(),
|
||||
requestType = HeaderInterceptor.getRequestType(),
|
||||
businessType = businessType,
|
||||
throwable = throwable
|
||||
)
|
||||
)
|
||||
val interceptorCloseables =
|
||||
request.getAttribute(HeaderInterceptorRest.CLASS_NAME) as HeaderInterceptor.InterceptorCloseables
|
||||
interceptorCloseables.close()
|
||||
} catch (e: java.lang.RuntimeException) {
|
||||
log.error(e.toString(), e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun isError(httpStatusCode: Int): Boolean {
|
||||
return httpStatusCode in 400..599
|
||||
}
|
||||
|
||||
@Throws(IOException::class)
|
||||
override fun intercept(
|
||||
request: HttpRequest,
|
||||
requestBytes: ByteArray, execution: ClientHttpRequestExecution
|
||||
): ClientHttpResponse {
|
||||
val requestTime = ZonedDateTime.now(clock)
|
||||
var responseSize = 0
|
||||
var responseHeaders: Map<String, Collection<String>> = emptyMap()
|
||||
var responseMediaType: MediaType? = null
|
||||
var httpStatusCode = -1
|
||||
var throwable: Throwable? = null
|
||||
var requestBody: String? = null
|
||||
var responseBody: String? = null
|
||||
var businessType: String? = null
|
||||
return try {
|
||||
val result = BufferingClientHttpResponseWrapper(
|
||||
execution.execute(request, requestBytes)
|
||||
)
|
||||
val responseBytes = StreamUtils.copyToByteArray(result.getBody())
|
||||
responseSize = responseBytes.size
|
||||
responseHeaders = extractHeaders(result.headers)
|
||||
responseMediaType = result.headers.getContentType()
|
||||
httpStatusCode = result.statusCode.value()
|
||||
if (responseLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| responseLogBehaviour == FieldLogBehaviour.ALWAYS
|
||||
) {
|
||||
responseBody = String(
|
||||
responseBytes,
|
||||
determineRequestEncoding()
|
||||
)
|
||||
}
|
||||
result
|
||||
} catch (e: Exception) {
|
||||
throwable = e
|
||||
throw e
|
||||
} finally {
|
||||
try {
|
||||
val url = request.uri.toURL()
|
||||
val requestHeaders: Map<String, Collection<String>> = extractHeaders(request.headers)
|
||||
if (requestLogBehaviour == FieldLogBehaviour.ONLY_ON_ERROR && isError(httpStatusCode)
|
||||
|| requestLogBehaviour == FieldLogBehaviour.ALWAYS
|
||||
) {
|
||||
requestBody = String(
|
||||
requestBytes,
|
||||
determineRequestEncoding()
|
||||
)
|
||||
businessType = determineBusinessType()
|
||||
}
|
||||
log(
|
||||
LogMessage(
|
||||
requestHeaders = requestHeaders,
|
||||
responseHeaders = responseHeaders,
|
||||
url = url,
|
||||
method = request.method.name(),
|
||||
requestMimeType = typeToString(request.headers.getContentType()),
|
||||
requestBody = requestBody,
|
||||
responseBody = responseBody,
|
||||
responseMimeType = typeToString(responseMediaType!!),
|
||||
requestSize = requestBytes.size,
|
||||
responseSize = responseSize,
|
||||
httpStatus = httpStatusCode,
|
||||
direction = DIRECTION_OUT,
|
||||
requestTime = requestTime,
|
||||
responseTime = ZonedDateTime.now(clock),
|
||||
businessType = businessType,
|
||||
throwable = throwable,
|
||||
traceId = HeaderInterceptorRest.extractTraceId(request),
|
||||
requestType = HeaderInterceptorRest.extractRequestType(request),
|
||||
)
|
||||
)
|
||||
} catch (e: java.lang.RuntimeException) {
|
||||
log.error(e.toString(), e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun log(logMessage: LogMessage) {
|
||||
val stringMapMessage = StringMapMessage()
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_REQUEST_HEADERS,
|
||||
toHeaderString(logMessage.requestHeaders)
|
||||
)
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_RESPONSE_HEADERS,
|
||||
toHeaderString(logMessage.responseHeaders)
|
||||
)
|
||||
addLogString(stringMapMessage, PARAM_URL_FULL, logMessage.url.toString())
|
||||
addLogString(stringMapMessage, PARAM_URL_DOMAIN, logMessage.url.host)
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_URL_EXTENSION,
|
||||
extractExtension(logMessage.url.path)
|
||||
)
|
||||
addLogString(stringMapMessage, PARAM_URL_PATH, logMessage.url.path)
|
||||
addLogString(stringMapMessage, PARAM_URL_PORT, logMessage.url.port.toString())
|
||||
addLogString(stringMapMessage, PARAM_URL_SCHEME, logMessage.url.protocol)
|
||||
addLogString(stringMapMessage, PARAM_URL_QUERY, logMessage.url.query)
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_METHOD, logMessage.method)
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_REQUEST_REFERER,
|
||||
getHeader(logMessage.requestHeaders, HttpHeaders.REFERER)
|
||||
)
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_MIMETYPE, logMessage.requestMimeType)
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_MIMETYPE, logMessage.responseMimeType)
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_BYTES, logMessage.requestSize.toString())
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_BYTES, logMessage.responseSize.toString())
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_STATUS, logMessage.httpStatus.toString())
|
||||
addLogString(stringMapMessage, PARAM_DIRECTION, logMessage.direction)
|
||||
addLogString(stringMapMessage, PARAM_PROTOCOL, PROTOCOL_NAME)
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_REQUEST_TIME,
|
||||
logMessage.requestTime.format(DATE_TIME_FORMATTER)
|
||||
)
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_RESPONSE_TIME,
|
||||
logMessage.responseTime.format(DATE_TIME_FORMATTER)
|
||||
)
|
||||
addLogString(
|
||||
stringMapMessage,
|
||||
PARAM_DURATION,
|
||||
getDurationBetweenRequestAndResponseTime(logMessage).toNanos().toString()
|
||||
)
|
||||
addLogString(
|
||||
stringMapMessage, PARAM_USER_AGENT,
|
||||
getHeader(logMessage.requestHeaders, HttpHeaders.USER_AGENT)
|
||||
)
|
||||
addLogString(stringMapMessage, HeaderInterceptor.LOGGER_TRACE_ID, logMessage.traceId)
|
||||
addLogString(stringMapMessage, HeaderInterceptor.LOGGER_REQTYPE_ID, logMessage.requestType)
|
||||
addLogString(stringMapMessage, PARAM_BUSINESS_TYPE, logMessage.businessType)
|
||||
addLogString(stringMapMessage, PARAM_REQUEST_BODY, cutToMaxLength(logMessage.requestBody))
|
||||
addLogString(stringMapMessage, PARAM_RESPONSE_BODY, cutToMaxLength(logMessage.responseBody))
|
||||
log.debug(MARKER, stringMapMessage.asString(), logMessage.throwable)
|
||||
}
|
||||
|
||||
private fun getDurationBetweenRequestAndResponseTime(logMessage: LogMessage): Duration {
|
||||
return Duration.between(logMessage.requestTime, logMessage.responseTime)
|
||||
}
|
||||
|
||||
private fun getHeader(headers: Map<String, Collection<String?>>, headerKey: String): String? {
|
||||
return headers.entries.asSequence()
|
||||
.filter { it.key.equals(headerKey, ignoreCase = true) }
|
||||
.flatMap { it.value.asSequence() }
|
||||
.firstOrNull()
|
||||
}
|
||||
|
||||
private fun addLogString(stringMapMessage: StringMapMessage, key: String, value: String?) {
|
||||
if (!value.isNullOrBlank()) {
|
||||
stringMapMessage.with(key, value.trim { it <= ' ' })
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* usually returns null, but can be overridden to implement more complex logic
|
||||
*/
|
||||
private fun determineBusinessType(): String? {
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* usually returns UTF-8, but can be overridden to implement more complex logic
|
||||
*/
|
||||
private fun determineRequestEncoding(): Charset {
|
||||
return StandardCharsets.UTF_8
|
||||
}
|
||||
|
||||
/**
|
||||
* usually returns UTF-8, but can be overridden to implement more complex logic
|
||||
*/
|
||||
private fun determineResponseEncoding(): Charset {
|
||||
return StandardCharsets.UTF_8
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val log = KotlinLogging.logger {}
|
||||
private const val MAX_LOG_SIZE = 20480 // 20 KB - logging could fail with bigger logmessages
|
||||
|
||||
val DATE_TIME_FORMATTER: DateTimeFormatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME
|
||||
val MARKER: Marker = MarkerFactory.getMarker("communication")
|
||||
|
||||
const val DIRECTION_IN = "inbound"
|
||||
const val DIRECTION_OUT = "outbound"
|
||||
const val PROTOCOL_NAME = "http"
|
||||
|
||||
const val PARAM_URL_FULL = "url.full"
|
||||
const val PARAM_URL_DOMAIN = "url.domain"
|
||||
const val PARAM_URL_EXTENSION = "url.extension"
|
||||
const val PARAM_URL_PATH = "url.path"
|
||||
const val PARAM_URL_PORT = "url.port"
|
||||
const val PARAM_URL_SCHEME = "url.scheme"
|
||||
const val PARAM_URL_QUERY = "url.query"
|
||||
const val PARAM_BUSINESS_TYPE = "http.request.type"
|
||||
const val PARAM_REQUEST_BODY = "http.request.body.content"
|
||||
const val PARAM_RESPONSE_BODY = "http.response.body.content"
|
||||
const val PARAM_RESPONSE_STATUS = "http.response.status_code"
|
||||
const val PARAM_REQUEST_HEADERS = "http.request.headers"
|
||||
const val PARAM_RESPONSE_HEADERS = "http.response.headers"
|
||||
const val PARAM_REQUEST_BYTES = "http.request.body.bytes"
|
||||
const val PARAM_RESPONSE_BYTES = "http.response.body.bytes"
|
||||
const val PARAM_REQUEST_MIMETYPE = "http.request.mime_type"
|
||||
const val PARAM_RESPONSE_MIMETYPE = "http.response.mime_type"
|
||||
const val PARAM_REQUEST_METHOD = "http.request.method"
|
||||
const val PARAM_REQUEST_REFERER = "http.request.referrer"
|
||||
const val PARAM_REQUEST_TIME = "event.start"
|
||||
const val PARAM_RESPONSE_TIME = "event.end"
|
||||
const val PARAM_DURATION = "event.duration"
|
||||
const val PARAM_USER_AGENT = "user_agent.original"
|
||||
const val PARAM_DIRECTION = "network.direction"
|
||||
const val PARAM_PROTOCOL = "network.protocol"
|
||||
|
||||
private fun extractHeaders(
|
||||
headerNames: Iterator<String>,
|
||||
ignoreList: List<String> = emptyList(),
|
||||
headerValuesSupplier: Function<String, Iterator<String>>
|
||||
): Map<String, MutableCollection<String>> {
|
||||
val requestHeaders: MutableMap<String, MutableCollection<String>> = mutableMapOf()
|
||||
while (headerNames.hasNext()) {
|
||||
val name = headerNames.next()
|
||||
if (name in ignoreList) continue
|
||||
val values = requestHeaders.computeIfAbsent(name) { mutableSetOf() }
|
||||
val headerValues = headerValuesSupplier.apply(name)
|
||||
while (headerValues.hasNext()) {
|
||||
values.add(headerValues.next())
|
||||
}
|
||||
}
|
||||
return requestHeaders
|
||||
}
|
||||
|
||||
private fun extractHeaders(headers: HttpHeaders): Map<String, Collection<String>> {
|
||||
val result: MutableMap<String, Collection<String>> = mutableMapOf()
|
||||
for ((key, value) in headers) {
|
||||
result[key] = value.toList()
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
private fun toHeaderString(headerMap: Map<String, Collection<String>>): String {
|
||||
return headerMap.entries.asSequence()
|
||||
.flatMap { entry ->
|
||||
val key = entry.key
|
||||
entry.value.asSequence().map { Pair(key, it) }
|
||||
}
|
||||
.map { "${it.first}=${it.second}" }
|
||||
.joinToString(separator = ",")
|
||||
}
|
||||
|
||||
private fun typeToString(contentType: String?): String? {
|
||||
return try {
|
||||
if (contentType == null) return null
|
||||
val mediaType = MediaType.parseMediaType(contentType)
|
||||
return typeToString(mediaType)
|
||||
} catch (e: InvalidMediaTypeException) {
|
||||
log.info(e.toString(), e)
|
||||
e.toString()
|
||||
}
|
||||
}
|
||||
|
||||
private fun typeToString(mediaType: MediaType?): String? {
|
||||
return try {
|
||||
if (mediaType == null) return null
|
||||
"${mediaType.type}/${mediaType.subtype}"
|
||||
} catch (e: RuntimeException) {
|
||||
log.info(e.toString(), e)
|
||||
e.toString()
|
||||
}
|
||||
}
|
||||
|
||||
private fun extractExtension(fileName: String?): String? {
|
||||
if (fileName == null || !fileName.contains(".")) return null
|
||||
return fileName.substring(fileName.lastIndexOf('.') + 1)
|
||||
}
|
||||
|
||||
private fun cutToMaxLength(string: String?): String? {
|
||||
return if (string != null && string.length > MAX_LOG_SIZE) {
|
||||
string.substring(0, MAX_LOG_SIZE)
|
||||
} else string
|
||||
}
|
||||
|
||||
private data class LogMessage(
|
||||
val requestHeaders: Map<String, Collection<String>>,
|
||||
val responseHeaders: Map<String, Collection<String>>,
|
||||
val url: URL,
|
||||
val method: String,
|
||||
val requestMimeType: String?,
|
||||
val responseMimeType: String?,
|
||||
val requestBody: String?,
|
||||
val responseBody: String?,
|
||||
val requestSize: Int,
|
||||
val responseSize: Int,
|
||||
val httpStatus: Int,
|
||||
val direction: String,
|
||||
val requestTime: ZonedDateTime,
|
||||
val responseTime: ZonedDateTime,
|
||||
val traceId: String?,
|
||||
val requestType: String?,
|
||||
val businessType: String?,
|
||||
val throwable: Throwable?
|
||||
)
|
||||
|
||||
enum class FieldLogBehaviour {
|
||||
NEVER,
|
||||
ONLY_ON_ERROR,
|
||||
ALWAYS
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
package de.twomartens.timetable.support.model.dto
|
||||
|
||||
data class ErrorMessage(val message: String)
|
||||
+83
@@ -0,0 +1,83 @@
|
||||
package de.twomartens.timetable.support.monitoring.actuator
|
||||
|
||||
import mu.KotlinLogging
|
||||
import org.slf4j.MDC
|
||||
import org.springframework.boot.actuate.health.Health
|
||||
import org.springframework.boot.actuate.health.HealthIndicator
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import java.io.IOException
|
||||
import java.time.Clock
|
||||
import java.time.Duration
|
||||
import java.util.*
|
||||
|
||||
abstract class AbstractHealthIndicator(
|
||||
private val clock: Clock,
|
||||
private val preparable: Preparable
|
||||
) : HealthIndicator {
|
||||
|
||||
private val logStatusDownMessage = "health indicator '${indicatorName()}' invoked with status '${Status.DOWN.code}'"
|
||||
private val logStatusUpMessage = "health indicator '${indicatorName()}' invoked with status '${Status.UP.code}'"
|
||||
|
||||
private var firstTime = true
|
||||
|
||||
/**
|
||||
* main method that determines the health of the service
|
||||
*/
|
||||
protected abstract fun determineHealth(): Health
|
||||
|
||||
override fun health(): Health {
|
||||
try {
|
||||
preparable.prepare().use {
|
||||
var result: Health? = null
|
||||
var exception: Exception? = null
|
||||
val start = clock.millis()
|
||||
try {
|
||||
result = determineHealth()
|
||||
} catch (e: RuntimeException) {
|
||||
exception = e
|
||||
result = Health.down().withException(e).build()
|
||||
} finally {
|
||||
logInvocation(result, exception, start, clock.millis())
|
||||
}
|
||||
return result!!
|
||||
}
|
||||
} catch (e: IOException) {
|
||||
log.error("unexpected exception occurred", e)
|
||||
return Health.down(e).build()
|
||||
}
|
||||
}
|
||||
|
||||
private fun logInvocation(health: Health?, exception: Exception?, start: Long, end: Long) {
|
||||
val duration = Duration.ofMillis(end - start)
|
||||
MDC.putCloseable("event.duration", duration.toNanos().toString()).use {
|
||||
if (exception != null || health == null) {
|
||||
log.error(logStatusDownMessage, exception)
|
||||
firstTime = true
|
||||
} else if (health.status === Status.DOWN) {
|
||||
log.warn(logStatusDownMessage)
|
||||
firstTime = true
|
||||
} else if (firstTime) {
|
||||
log.info(logStatusUpMessage)
|
||||
firstTime = false
|
||||
} else {
|
||||
log.trace(logStatusUpMessage)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun indicatorName(): String {
|
||||
return this.javaClass.getSimpleName()
|
||||
.replace("HealthIndicator", "")
|
||||
.lowercase(Locale.getDefault())
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val HOST = "localhost"
|
||||
const val HTTP_PREFIX = "http://"
|
||||
const val HOST_PORT_SEPARATOR = ":"
|
||||
const val PATH_SEPARATOR = "/"
|
||||
const val PARAMETER_SEPARATOR = "?"
|
||||
const val DETAIL_ENDPOINT_KEY = "endpoint"
|
||||
private val log = KotlinLogging.logger {}
|
||||
}
|
||||
}
|
||||
+30
@@ -0,0 +1,30 @@
|
||||
package de.twomartens.timetable.support.monitoring.actuator
|
||||
|
||||
import de.twomartens.timetable.support.monitoring.statusprobe.StatusProbe
|
||||
import org.springframework.boot.actuate.health.Health
|
||||
import org.springframework.boot.actuate.health.HealthIndicator
|
||||
import java.time.Clock
|
||||
|
||||
abstract class AbstractStatusProbeHealthIndicator(
|
||||
timeProvider: Clock, headerInterceptor: Preparable,
|
||||
private val statusProbe: StatusProbe
|
||||
) : AbstractHealthIndicator(timeProvider, headerInterceptor), HealthIndicator {
|
||||
override fun determineHealth(): Health {
|
||||
val healthBuilder = Health.status(statusProbe.status)
|
||||
if (statusProbe.lastStatusChange != null) {
|
||||
healthBuilder.withDetail(LAST_STATUS_CHANGE_KEY, statusProbe.lastStatusChange)
|
||||
}
|
||||
if (statusProbe.throwable != null) {
|
||||
healthBuilder.withException(statusProbe.throwable)
|
||||
}
|
||||
if (statusProbe.message != null) {
|
||||
healthBuilder.withDetail(MESSAGE_KEY, statusProbe.message)
|
||||
}
|
||||
return healthBuilder.build()
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val MESSAGE_KEY = "message"
|
||||
const val LAST_STATUS_CHANGE_KEY = "lastStatusChange"
|
||||
}
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
package de.twomartens.timetable.support.monitoring.actuator
|
||||
|
||||
import java.io.Closeable
|
||||
|
||||
fun interface Preparable {
|
||||
fun prepare(): Closeable
|
||||
}
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
package de.twomartens.timetable.support.monitoring.actuator
|
||||
|
||||
import de.twomartens.timetable.support.interceptor.HeaderInterceptorRest
|
||||
import de.twomartens.timetable.property.ServiceProperties
|
||||
import org.springframework.boot.actuate.health.Health
|
||||
import org.springframework.boot.actuate.health.HealthIndicator
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import org.springframework.boot.autoconfigure.web.ServerProperties
|
||||
import org.springframework.stereotype.Component
|
||||
import org.springframework.web.client.RestTemplate
|
||||
import java.security.SecureRandom
|
||||
import java.time.Clock
|
||||
|
||||
/**
|
||||
* A Health check which checks if the rest services are working.
|
||||
*
|
||||
*
|
||||
* If you have a complex service, you should think about an easy greeting or echo service, which
|
||||
* only tests the
|
||||
* network/service stack and not the full application.
|
||||
*
|
||||
*
|
||||
* The health check will be called by kubernetes to check if the container/pod should be in load
|
||||
* balancing. It is possible
|
||||
* to have as much health checks as you like.
|
||||
*
|
||||
*
|
||||
* There should be a health check which is ok not before all data is loaded.
|
||||
*/
|
||||
@Component
|
||||
class RestHealthIndicator(
|
||||
clock: Clock, interceptor: HeaderInterceptorRest,
|
||||
serverProperties: ServerProperties,
|
||||
private val restTemplateRestHealthIndicator: RestTemplate,
|
||||
private val serviceProperties: ServiceProperties
|
||||
) : AbstractHealthIndicator(clock, Preparable { interceptor.markAsHealthCheck() }), HealthIndicator {
|
||||
private val randomizer = SecureRandom()
|
||||
private val urlPrefix: String = (HTTP_PREFIX + HOST + HOST_PORT_SEPARATOR
|
||||
+ serverProperties.port
|
||||
+ URL_PATH + PARAMETER_SEPARATOR + GET_PARAMETER)
|
||||
|
||||
/**
|
||||
* main method that determines the health of the service
|
||||
*/
|
||||
override fun determineHealth(): Health {
|
||||
val random = randomizer.nextInt(100000, 999999).toString()
|
||||
val url = "$urlPrefix{random}"
|
||||
val response = restTemplateRestHealthIndicator.getForEntity(url, String::class.java, random)
|
||||
val status = if (response.body == serviceProperties.greeting.format(random)) Status.UP else Status.DOWN
|
||||
return Health.status(status)
|
||||
.withDetail(DETAIL_ENDPOINT_KEY, url)
|
||||
.build()
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val URL_PATH = "/timetable/v1/healthCheck"
|
||||
private const val GET_PARAMETER = "message="
|
||||
}
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import java.time.Clock
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
|
||||
class CountBasedStatusProbe(
|
||||
private val maxFailureCount: Int, clock: Clock, criticality: StatusProbeCriticality, name: String,
|
||||
statusProbeLogger: StatusProbeLogger
|
||||
) : StatusProbe(clock, criticality, name, statusProbeLogger) {
|
||||
private val failureCount = AtomicInteger(0)
|
||||
|
||||
@Synchronized
|
||||
override fun setStatus(status: Status, throwable: Throwable?, message: String?) {
|
||||
if (status === Status.DOWN) {
|
||||
val failureCount = failureCount.incrementAndGet()
|
||||
if (failureCount > maxFailureCount) {
|
||||
super.setStatus(status, throwable, message)
|
||||
}
|
||||
} else if (status === Status.UP) {
|
||||
failureCount.set(0)
|
||||
super.setStatus(status, throwable, message)
|
||||
}
|
||||
}
|
||||
}
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler
|
||||
import java.time.Clock
|
||||
import java.time.Duration
|
||||
|
||||
/**
|
||||
* uses the percentage of down statuses within a given period (default: 1 min) to determine if status of probe is down.
|
||||
* this is meant to be used to avoid flickering status probes on services that have lots of status updates. When there
|
||||
* is no significant amount of requests during one scheduling period, the behavior may be arbitrary.
|
||||
*/
|
||||
class PercentageBasedStatusProbe(
|
||||
private val maxFailurePercent: Int, clock: Clock,
|
||||
threadPoolTaskScheduler: ThreadPoolTaskScheduler, schedulePeriod: Duration, criticality: StatusProbeCriticality,
|
||||
name: String, statusProbeLogger: StatusProbeLogger
|
||||
) : StatusProbe(clock, criticality, name, statusProbeLogger), ScheduledStatusProbe {
|
||||
private var requestCount = 0
|
||||
private var downCount = 0
|
||||
private var temporaryMessage: String? = null
|
||||
private var temporaryThrowable: Throwable? = null
|
||||
|
||||
init {
|
||||
scheduleTask(threadPoolTaskScheduler, schedulePeriod)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
override fun setStatus(status: Status, throwable: Throwable?, message: String?) {
|
||||
if (status === Status.DOWN) {
|
||||
downCount++
|
||||
this.temporaryThrowable = throwable
|
||||
this.temporaryMessage = message
|
||||
}
|
||||
requestCount++
|
||||
}
|
||||
|
||||
private fun reset() {
|
||||
requestCount = 0
|
||||
downCount = 0
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
override fun runScheduledTask() {
|
||||
if (requestCount > 0 && downCount * 100.0 / requestCount > maxFailurePercent) {
|
||||
super.setStatus(Status.DOWN, temporaryThrowable, temporaryMessage)
|
||||
} else {
|
||||
super.setStatus(Status.UP, null, null)
|
||||
}
|
||||
reset()
|
||||
}
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler
|
||||
import org.springframework.scheduling.support.PeriodicTrigger
|
||||
import java.time.Duration
|
||||
|
||||
interface ScheduledStatusProbe {
|
||||
fun runScheduledTask()
|
||||
fun scheduleTask(
|
||||
threadPoolTaskScheduler: ThreadPoolTaskScheduler,
|
||||
schedulePeriod: Duration
|
||||
) {
|
||||
val periodicTrigger = PeriodicTrigger(
|
||||
Duration.ofSeconds(schedulePeriod.toSeconds())
|
||||
)
|
||||
threadPoolTaskScheduler.schedule(periodicTrigger) { runScheduledTask() }
|
||||
}
|
||||
}
|
||||
|
||||
fun ThreadPoolTaskScheduler.schedule(periodicTrigger: PeriodicTrigger, task: Runnable) {
|
||||
this.schedule(task, periodicTrigger)
|
||||
}
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
import lombok.Getter
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import java.time.Clock
|
||||
import java.time.ZonedDateTime
|
||||
|
||||
@Getter
|
||||
open class StatusProbe(
|
||||
private val clock: Clock, criticality: StatusProbeCriticality, private val name: String,
|
||||
private val statusProbeLogger: StatusProbeLogger
|
||||
) {
|
||||
var status: Status = Status.UP
|
||||
private set
|
||||
var throwable: Throwable? = null
|
||||
private set
|
||||
var message: String? = null
|
||||
private set
|
||||
var lastStatusChange: ZonedDateTime? = null
|
||||
private set
|
||||
|
||||
init {
|
||||
statusProbeLogger.registerStatusProbe(name, criticality)
|
||||
}
|
||||
|
||||
protected open fun setStatus(status: Status, throwable: Throwable?, message: String?) {
|
||||
if (status !== this.status) {
|
||||
lastStatusChange = ZonedDateTime.now(clock)
|
||||
statusProbeLogger.logStatusChange(name, message, status, lastStatusChange, throwable)
|
||||
}
|
||||
this.status = status
|
||||
this.throwable = throwable
|
||||
this.message = message
|
||||
}
|
||||
|
||||
fun up() {
|
||||
setStatus(Status.UP, null, null)
|
||||
}
|
||||
|
||||
fun up(message: String) {
|
||||
setStatus(Status.UP, null, message)
|
||||
}
|
||||
|
||||
fun down() {
|
||||
setStatus(Status.DOWN, null, null)
|
||||
}
|
||||
|
||||
fun down(throwable: Throwable) {
|
||||
setStatus(Status.DOWN, throwable, null)
|
||||
}
|
||||
|
||||
fun down(message: String) {
|
||||
setStatus(Status.DOWN, null, message)
|
||||
}
|
||||
|
||||
protected fun down(throwable: Throwable, message: String) {
|
||||
setStatus(Status.DOWN, throwable, message)
|
||||
}
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
enum class StatusProbeCriticality {
|
||||
K1,
|
||||
K2,
|
||||
K3
|
||||
}
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
import org.apache.logging.log4j.LogManager
|
||||
import org.apache.logging.log4j.Logger
|
||||
import org.apache.logging.log4j.MarkerManager
|
||||
import org.apache.logging.log4j.message.StringMapMessage
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import java.time.Clock
|
||||
import java.time.ZonedDateTime
|
||||
|
||||
class StatusProbeLogger internal constructor(private val clock: Clock, private val commLog: Logger) {
|
||||
private val statusProbeToStatus: MutableMap<ProbeIdent, Status> = mutableMapOf()
|
||||
|
||||
constructor(clock: Clock) : this(clock, LogManager.getLogger("statusprobe"))
|
||||
|
||||
fun registerStatusProbe(name: String, criticality: StatusProbeCriticality) {
|
||||
statusProbeToStatus[ProbeIdent(name, criticality)] = Status.UP
|
||||
logStatusChange(name, "Startup", Status.UP, ZonedDateTime.now(clock), null)
|
||||
}
|
||||
|
||||
fun logStatusChange(
|
||||
name: String, message: String?, status: Status, lastStatusChange: ZonedDateTime?,
|
||||
throwable: Throwable?
|
||||
) {
|
||||
var probeIdent = getProbeIdent(name)
|
||||
if (probeIdent == null) {
|
||||
probeIdent = ProbeIdent(name, StatusProbeCriticality.K1)
|
||||
}
|
||||
statusProbeToStatus[probeIdent] = status
|
||||
createLog(message, lastStatusChange, throwable)
|
||||
}
|
||||
|
||||
private fun getProbeIdent(name: String): ProbeIdent? {
|
||||
return statusProbeToStatus.keys.asSequence()
|
||||
.filter { it.name == name }
|
||||
.firstOrNull()
|
||||
}
|
||||
|
||||
private fun createLog(message: String?, lastStatusChange: ZonedDateTime?, throwable: Throwable?) {
|
||||
val cleanedMessage = message ?: ""
|
||||
val overallStatus = overallStatus
|
||||
val criticality = overallCriticality
|
||||
if (Status.UP == overallStatus) {
|
||||
commLog.info(
|
||||
MARKER, StringMapMessage()
|
||||
.with(LABEL_CRITICALITY, criticality)
|
||||
.with(LABEL_STATUS, overallStatus)
|
||||
.with(LABEL_MESSAGE, cleanedMessage)
|
||||
.with(LABEL_LAST_STATUS_CHANGE, lastStatusChange)
|
||||
)
|
||||
} else {
|
||||
commLog.error(
|
||||
MARKER, StringMapMessage()
|
||||
.with(LABEL_CRITICALITY, criticality)
|
||||
.with(LABEL_STATUS, overallStatus)
|
||||
.with(LABEL_MESSAGE, cleanedMessage)
|
||||
.with(LABEL_REASON, reason)
|
||||
.with(LABEL_LAST_STATUS_CHANGE, lastStatusChange), throwable
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private val overallCriticality: StatusProbeCriticality
|
||||
get() {
|
||||
val crits = statusProbeToStatus.keys.asSequence()
|
||||
.map { it.criticality }
|
||||
.toList()
|
||||
return if (crits.contains(StatusProbeCriticality.K1)) StatusProbeCriticality.K1
|
||||
else if (crits.contains(StatusProbeCriticality.K2)) StatusProbeCriticality.K2
|
||||
else StatusProbeCriticality.K3
|
||||
}
|
||||
|
||||
private val overallStatus: Status
|
||||
get() = if (statusProbeToStatus.containsValue(Status.DOWN)) Status.DOWN
|
||||
else Status.UP
|
||||
|
||||
private val reason: String
|
||||
get() {
|
||||
val probesDown = statusProbeToStatus.entries.asSequence()
|
||||
.filter { it.value == Status.DOWN }
|
||||
.map { it.key }
|
||||
.toList()
|
||||
val reasonK1 = getDownStatusProbes(probesDown, StatusProbeCriticality.K1)
|
||||
val reasonK2 = getDownStatusProbes(probesDown, StatusProbeCriticality.K2)
|
||||
val reasonK3 = getDownStatusProbes(probesDown, StatusProbeCriticality.K3)
|
||||
return "$reasonK1$reasonK2$reasonK3".trim { it <= ' ' }
|
||||
}
|
||||
|
||||
private fun getDownStatusProbes(probesDown: List<ProbeIdent>, criticality: StatusProbeCriticality): String {
|
||||
val downProbeNames = probesDown.asSequence()
|
||||
.filter { it.criticality == criticality }
|
||||
.map { it.name }
|
||||
.toList()
|
||||
return if (downProbeNames.isNotEmpty()) {
|
||||
"$criticality failed: ${downProbeNames.joinToString(separator = ",")}\n"
|
||||
} else ""
|
||||
}
|
||||
|
||||
data class ProbeIdent(val name: String, val criticality: StatusProbeCriticality)
|
||||
|
||||
companion object {
|
||||
private val MARKER = MarkerManager.getMarker("statusprobe")
|
||||
private const val LABEL_CRITICALITY = "label.status.criticality"
|
||||
private const val LABEL_STATUS = "label.status.status"
|
||||
private const val LABEL_REASON = "label.status.reason"
|
||||
private const val LABEL_MESSAGE = "label.status.description"
|
||||
private const val LABEL_LAST_STATUS_CHANGE = "label.status.last_change"
|
||||
}
|
||||
}
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
package de.twomartens.timetable.support.monitoring.statusprobe
|
||||
|
||||
import org.springframework.boot.actuate.health.Status
|
||||
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler
|
||||
import java.time.Clock
|
||||
import java.time.Duration
|
||||
import java.time.ZonedDateTime
|
||||
|
||||
class TimeBasedStatusProbe(
|
||||
private val maxFailureDuration: Duration, private val clock: Clock,
|
||||
threadPoolTaskScheduler: ThreadPoolTaskScheduler, schedulePeriod: Duration, criticality: StatusProbeCriticality,
|
||||
name: String, statusProbeLogger: StatusProbeLogger
|
||||
) : StatusProbe(clock, criticality, name, statusProbeLogger), ScheduledStatusProbe {
|
||||
private var lastSuccess: ZonedDateTime? = null
|
||||
private var temporaryThrowable: Throwable? = null
|
||||
private var temporaryMessage: String? = null
|
||||
|
||||
init {
|
||||
scheduleTask(threadPoolTaskScheduler, schedulePeriod)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
override fun setStatus(status: Status, throwable: Throwable?, message: String?) {
|
||||
if (status === Status.DOWN) {
|
||||
this.temporaryThrowable = throwable
|
||||
this.temporaryMessage = message
|
||||
} else if (status === Status.UP) {
|
||||
lastSuccess = ZonedDateTime.now(clock)
|
||||
super.setStatus(status, throwable, message)
|
||||
}
|
||||
}
|
||||
|
||||
private val isOverdue: Boolean
|
||||
get() {
|
||||
if (lastSuccess == null) {
|
||||
return false
|
||||
}
|
||||
val timeSinceLastSuccess = Duration.between(lastSuccess, ZonedDateTime.now(clock))
|
||||
return maxFailureDuration.minus(timeSinceLastSuccess).isNegative
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
override fun runScheduledTask() {
|
||||
if (isOverdue) {
|
||||
super.setStatus(Status.DOWN, temporaryThrowable, temporaryMessage)
|
||||
}
|
||||
}
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
package de.twomartens.timetable.property
|
||||
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties
|
||||
import org.springframework.boot.context.properties.bind.ConstructorBinding
|
||||
import org.springframework.boot.convert.DurationUnit
|
||||
import java.time.Duration
|
||||
import java.time.temporal.ChronoUnit
|
||||
|
||||
@ConfigurationProperties(prefix = "resttemplate.timeout")
|
||||
data class RestTemplateTimeoutProperties @ConstructorBinding constructor(
|
||||
@DurationUnit(ChronoUnit.MILLIS) val readTimeoutRestHealthIndicatorInMillis: Duration,
|
||||
@DurationUnit(ChronoUnit.MILLIS) val connectionRestHealthIndicatorTimeoutInMillis: Duration,
|
||||
@DurationUnit(ChronoUnit.MILLIS) val readTimeoutRestTemplateInMillis: Duration,
|
||||
@DurationUnit(ChronoUnit.MILLIS) val connectionRestTemplateTimeoutInMillis: Duration
|
||||
)
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
package de.twomartens.timetable.property
|
||||
|
||||
import io.swagger.v3.oas.annotations.media.Schema
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties
|
||||
import org.springframework.boot.context.properties.bind.ConstructorBinding
|
||||
import org.springframework.boot.convert.DurationUnit
|
||||
import org.springframework.cloud.context.config.annotation.RefreshScope
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import java.time.Duration
|
||||
import java.time.temporal.ChronoUnit
|
||||
|
||||
@RefreshScope
|
||||
@ConfigurationProperties(prefix = "de.twomartens.timetable.statusprobe")
|
||||
@Schema(description = "Properties, to configure this Application")
|
||||
data class StatusProbeProperties @ConstructorBinding constructor(
|
||||
@DurationUnit(ChronoUnit.SECONDS) val scheduleDuration: Duration,
|
||||
@DurationUnit(ChronoUnit.MINUTES) val maxKafkaFailureDuration: Duration,
|
||||
val maxBlobFailureCount: Int,
|
||||
val maxFailurePercent: Int
|
||||
)
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
package de.twomartens.timetable.property
|
||||
|
||||
import io.swagger.v3.oas.annotations.media.Schema
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties
|
||||
import org.springframework.boot.context.properties.bind.ConstructorBinding
|
||||
import org.springframework.cloud.context.config.annotation.RefreshScope
|
||||
import java.time.ZoneId
|
||||
|
||||
@RefreshScope
|
||||
@ConfigurationProperties(prefix = "time")
|
||||
@Schema(description = "Properties to configure time")
|
||||
data class TimeProperties @ConstructorBinding constructor(
|
||||
val defaultTimeZone: ZoneId
|
||||
)
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
package de.twomartens.timetable.support.security
|
||||
|
||||
import mu.KotlinLogging
|
||||
import org.keycloak.AuthorizationContext
|
||||
import org.keycloak.adapters.authorization.PolicyEnforcer
|
||||
import org.keycloak.adapters.authorization.spi.HttpRequest
|
||||
import org.keycloak.adapters.authorization.spi.HttpResponse
|
||||
import org.keycloak.authorization.client.ClientAuthorizationContext
|
||||
import org.keycloak.representations.adapters.config.PolicyEnforcerConfig
|
||||
import org.keycloak.representations.adapters.config.PolicyEnforcerConfig.EnforcementMode
|
||||
import org.keycloak.representations.idm.authorization.Permission
|
||||
|
||||
class SpringPolicyEnforcer(private val policyEnforcer: PolicyEnforcer,
|
||||
private val policyEnforcerConfig: PolicyEnforcerConfig) {
|
||||
|
||||
fun enforce(request: HttpRequest, response: HttpResponse): AuthorizationContext {
|
||||
if (log.isDebugEnabled) {
|
||||
log.debug("Policy enforcement is enabled. Enforcing policy decisions for path [{}].", request.uri)
|
||||
}
|
||||
val context = authorize(request, response)
|
||||
if (log.isDebugEnabled) {
|
||||
log.debug("Policy enforcement result for path [{}] is : {}", request.uri, if (context.isGranted) "GRANTED" else "DENIED")
|
||||
log.debug("Returning authorization context with permissions:")
|
||||
for (permission in context.permissions) {
|
||||
log.debug(permission.toString())
|
||||
}
|
||||
}
|
||||
return context
|
||||
}
|
||||
|
||||
private fun authorize(request: HttpRequest, response: HttpResponse): AuthorizationContext {
|
||||
val enforcementMode = policyEnforcerConfig.enforcementMode
|
||||
return if (EnforcementMode.DISABLED == enforcementMode) {
|
||||
createAuthorizedContext()
|
||||
} else policyEnforcer.enforce(request, response)
|
||||
}
|
||||
|
||||
private fun createAuthorizedContext(): AuthorizationContext {
|
||||
return object : ClientAuthorizationContext(policyEnforcer.authzClient) {
|
||||
override fun hasPermission(resourceName: String, scopeName: String): Boolean {
|
||||
return true
|
||||
}
|
||||
|
||||
override fun hasResourcePermission(resourceName: String): Boolean {
|
||||
return true
|
||||
}
|
||||
|
||||
override fun hasScopePermission(scopeName: String): Boolean {
|
||||
return true
|
||||
}
|
||||
|
||||
override fun getPermissions(): List<Permission> {
|
||||
return emptyList()
|
||||
}
|
||||
|
||||
override fun isGranted(): Boolean {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val log = KotlinLogging.logger {}
|
||||
}
|
||||
}
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
package de.twomartens.timetable.support.security
|
||||
|
||||
import jakarta.servlet.*
|
||||
import jakarta.servlet.http.HttpServletRequest
|
||||
import jakarta.servlet.http.HttpServletResponse
|
||||
import mu.KotlinLogging
|
||||
import org.keycloak.AuthorizationContext
|
||||
import org.keycloak.adapters.authorization.PolicyEnforcer
|
||||
import org.keycloak.adapters.authorization.integration.elytron.ServletHttpRequest
|
||||
import org.keycloak.adapters.authorization.integration.elytron.ServletHttpResponse
|
||||
import org.keycloak.adapters.authorization.spi.ConfigurationResolver
|
||||
import org.keycloak.adapters.authorization.spi.HttpRequest
|
||||
import org.keycloak.representations.adapters.config.PolicyEnforcerConfig
|
||||
import java.io.IOException
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
|
||||
|
||||
class SpringPolicyEnforcerFilter(private val configResolver: ConfigurationResolver) : Filter {
|
||||
private val policyEnforcer: MutableMap<PolicyEnforcerConfig, SpringPolicyEnforcer> = ConcurrentHashMap()
|
||||
|
||||
@Throws(IOException::class, ServletException::class)
|
||||
override fun doFilter(servletRequest: ServletRequest, servletResponse: ServletResponse?, filterChain: FilterChain) {
|
||||
val request = servletRequest as HttpServletRequest
|
||||
val response = servletResponse as HttpServletResponse?
|
||||
val httpRequest = ServletHttpRequest(request) { extractBearerToken(request) }
|
||||
val policyEnforcer = getOrCreatePolicyEnforcer(httpRequest)
|
||||
val authzContext = policyEnforcer.enforce(httpRequest, ServletHttpResponse(response))
|
||||
request.setAttribute(AuthorizationContext::class.java.name, authzContext)
|
||||
if (authzContext.isGranted) {
|
||||
log.debug("Request authorized, continuing the filter chain")
|
||||
filterChain.doFilter(servletRequest, servletResponse)
|
||||
} else {
|
||||
log.debug("Unauthorized request to path [{}], aborting the filter chain", request.requestURI)
|
||||
}
|
||||
}
|
||||
|
||||
private fun extractBearerToken(request: HttpServletRequest): String? {
|
||||
val authorizationHeaderValues = request.getHeaders("Authorization")
|
||||
while (authorizationHeaderValues.hasMoreElements()) {
|
||||
val value = authorizationHeaderValues.nextElement()
|
||||
val parts = value.trim()
|
||||
.split("\\s+".toRegex())
|
||||
.dropLastWhile { it.isEmpty() }
|
||||
.toTypedArray()
|
||||
if (parts.size != 2) {
|
||||
continue
|
||||
}
|
||||
val bearer = parts[0]
|
||||
if (bearer.equals("Bearer", ignoreCase = true)) {
|
||||
return parts[1]
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun getOrCreatePolicyEnforcer(request: HttpRequest): SpringPolicyEnforcer {
|
||||
return policyEnforcer.computeIfAbsent(configResolver.resolve(request)) { createPolicyEnforcer(it) }
|
||||
}
|
||||
|
||||
private fun createPolicyEnforcer(enforcerConfig: PolicyEnforcerConfig): SpringPolicyEnforcer {
|
||||
val authServerUrl = enforcerConfig.authServerUrl
|
||||
return SpringPolicyEnforcer(PolicyEnforcer.builder()
|
||||
.authServerUrl(authServerUrl)
|
||||
.realm(enforcerConfig.realm)
|
||||
.clientId(enforcerConfig.resource)
|
||||
.credentials(enforcerConfig.credentials)
|
||||
.bearerOnly(false)
|
||||
.enforcerConfig(enforcerConfig).build(), enforcerConfig)
|
||||
}
|
||||
|
||||
companion object {
|
||||
private val log = KotlinLogging.logger {}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,9 @@
|
||||
#TODO zufaellige Ports eintragen
|
||||
server.port: 12000
|
||||
grpc.server.port: 12002
|
||||
management.server.port: 12001
|
||||
server.port: 12100
|
||||
management.server.port: 12101
|
||||
|
||||
de.twomartens.template.name: "Template"
|
||||
|
||||
spring:
|
||||
config:
|
||||
import:
|
||||
- "classpath:config/timetable.yaml"
|
||||
- "optional:configserver:${CONFIGSERVER_SCHEME:http}://${CONFIGSERVER_HOST:localhost}:${CONFIGSERVER_PORT:8888}${CONFIGSERVER_PREFIX:/config}"
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
spring:
|
||||
config:
|
||||
import:
|
||||
- "configserver:${CONFIGSERVER_SCHEME:http}://${CONFIGSERVER_HOST:configserver}:${CONFIGSERVER_PORT:8888}${CONFIGSERVER_PREFIX:/config}"
|
||||
kafka:
|
||||
bootstrap-servers:
|
||||
- ${KAFKA_HOST:kafka}:${KAFKA_PORT:9092}
|
||||
@@ -1,12 +1,12 @@
|
||||
server:
|
||||
port: 8080
|
||||
port: 12100
|
||||
shutdown: graceful
|
||||
grpc.server.port: 9090
|
||||
forward-headers-strategy: framework
|
||||
|
||||
### technical configurations ###
|
||||
management:
|
||||
# for security, don't use same port as application
|
||||
server.port: 8081
|
||||
server.port: 12101
|
||||
health:
|
||||
livenessState.enabled: true
|
||||
readinessState.enabled: true
|
||||
@@ -15,7 +15,7 @@ management:
|
||||
show-details: always
|
||||
probes.enabled: true
|
||||
group:
|
||||
readiness.include: readinessState,diskSpace,grpcChannel,grpc,rest
|
||||
readiness.include: readinessState,diskSpace,rest
|
||||
liveness.include: livenessState
|
||||
endpoints.web.exposure.include: '*'
|
||||
# activate percentiles for web and grpc requests
|
||||
@@ -24,44 +24,61 @@ management:
|
||||
http.server.requests: true
|
||||
|
||||
spring:
|
||||
cloud:
|
||||
config:
|
||||
name: timetable
|
||||
main:
|
||||
banner-mode: off
|
||||
profiles:
|
||||
default: dev
|
||||
|
||||
# properties for application
|
||||
de.twomartens.template:
|
||||
defaultTimeZone: Europe/Berlin
|
||||
greeting: "Hello %s"
|
||||
data.mongodb:
|
||||
uri: ${MONGODB_CONNECTION_STRING}
|
||||
auto-index-creation: true
|
||||
security:
|
||||
oauth2:
|
||||
resourceserver:
|
||||
jwt:
|
||||
jwk-set-uri: ${KEYCLOAK_URL:https://id.2martens.de}/realms/${KEYCLOAK_REALM:2martens}/protocol/openid-connect/certs
|
||||
application:
|
||||
name: timetable
|
||||
|
||||
springdoc:
|
||||
swagger-ui:
|
||||
path: '/template/doc/'
|
||||
api-docs:
|
||||
path: '/template/api-docs/'
|
||||
display-request-duration: true
|
||||
operationsSorter: method
|
||||
disable-swagger-default-url: true
|
||||
path: '/timetable/v1/doc/'
|
||||
default-produces-media-type: 'application/json'
|
||||
api-docs:
|
||||
path: '/timetable/v1/api-docs'
|
||||
|
||||
openapi:
|
||||
#TODO write description/ changelog
|
||||
description: |
|
||||
Open API Documentation for the Template
|
||||
|
||||
## Header 2
|
||||
|
||||
__YOUR TEXT HERE__
|
||||
|
||||
Open API Documentation for the Timetable API
|
||||
|
||||
TODO
|
||||
|
||||
|
||||
## Changelog
|
||||
|
||||
|Version | Change | Author | Date |
|
||||
| ------ | -------------------------------------- | ------ | ---------- |
|
||||
| 1.0 | added API Versioning (and changelog) | Jim | 28.05.2023 |
|
||||
| 1.0 | added API Versioning (and changelog) | Jim | 13.07.2023 |
|
||||
|
||||
version: 1.0
|
||||
title: 'Template API'
|
||||
title: 'Timetable API'
|
||||
|
||||
resttemplate:
|
||||
timeout:
|
||||
readTimeoutRestHealthIndicatorInMillis: 5000
|
||||
connectionRestHealthIndicatorTimeoutInMillis: 5000
|
||||
readTimeoutRestTemplateInMillis: 5000
|
||||
connectionRestTemplateTimeoutInMillis: 5000
|
||||
connectionRestTemplateTimeoutInMillis: 5000
|
||||
|
||||
de.twomartens.timetable:
|
||||
bahn-api:
|
||||
client-id: ${DB_CLIENT_ID}
|
||||
client-secret: ${DB_CLIENT_SECRET}
|
||||
|
||||
time:
|
||||
defaultTimeZone: Europe/Berlin
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
de.twomartens.timetable:
|
||||
greeting: "Moin %s, you are test"
|
||||
@@ -0,0 +1,7 @@
|
||||
de.twomartens.timetable:
|
||||
greeting: "Hello %s, on millenium"
|
||||
statusprobe:
|
||||
scheduleDuration: 60
|
||||
maxKafkaFailureDuration: 5
|
||||
maxBlobFailureCount: 5
|
||||
maxFailurePercent: 50
|
||||
@@ -16,5 +16,6 @@
|
||||
<AppenderRef ref="console"/>
|
||||
</Root>
|
||||
<Logger additivity="true" level="INFO" name="statusprobe"/>
|
||||
<Logger additivity="true" level="DEBUG" name="de.twomartens.timetable"/>
|
||||
</Loggers>
|
||||
</Configuration>
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"realm": "2martens",
|
||||
"auth-server-url": "https://id.2martens.de",
|
||||
"resource": "timetable",
|
||||
"http-method-as-scope": true
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
<!DOCTYPE html>
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org" lang="en">
|
||||
<th:block th:insert="~{errorIncludes :: head}"/>
|
||||
<body>
|
||||
<th:block th:insert="~{errorIncludes :: mainText}"/>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<!DOCTYPE html>
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org" lang="en">
|
||||
<th:block th:insert="~{errorIncludes :: head}" />
|
||||
<body>
|
||||
<th:block th:insert="~{errorIncludes :: mainText}" />
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<!DOCTYPE html>
|
||||
<html xmlns:th="http://www.thymeleaf.org">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org" lang="en">
|
||||
<head th:fragment="head">
|
||||
<title>Error <th:block th:text="${status}"/> (<th:block th:text="${error}"/>)</title>
|
||||
<style>
|
||||
@@ -18,7 +18,7 @@
|
||||
</head>
|
||||
<body>
|
||||
<th:block th:fragment="mainText">
|
||||
<h1>Template</h1>
|
||||
<h1>TSW Timetable</h1>
|
||||
<p>
|
||||
<b th:text="${status}"></b> <th:block th:text="${error}" />
|
||||
</p>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
<!DOCTYPE html>
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org" lang="en">
|
||||
<head th:fragment="head">
|
||||
<title><th:block th:text="${version}"/></title>
|
||||
<title th:text="${version}"></title>
|
||||
<style>
|
||||
@media (prefers-color-scheme: dark) {
|
||||
html{background:#000000;color:#ffffff;font:15px/22px arial,sans-serif}
|
||||
|
||||
Reference in New Issue
Block a user