Merge pull request #185 from companieshouse/feature/dsnd-2876_update_structured_logging

DSND-2876: Implement structured logging

Author: sthompsonCH

src/main/java/uk/gov/companieshouse/pscdataapi/api/ChsKafkaApiService.java

@@ -1,6 +1,7 @@
 package uk.gov.companieshouse.pscdataapi.api;
 
 import static java.time.ZoneOffset.UTC;
+import static uk.gov.companieshouse.pscdataapi.PscDataApiApplication.APPLICATION_NAME_SPACE;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -17,6 +18,7 @@
 import uk.gov.companieshouse.api.handler.chskafka.request.PrivateChangedResourcePost;
 import uk.gov.companieshouse.api.model.ApiResponse;
 import uk.gov.companieshouse.logging.Logger;
+import uk.gov.companieshouse.logging.LoggerFactory;
 import uk.gov.companieshouse.pscdataapi.exceptions.SerDesException;
 import uk.gov.companieshouse.pscdataapi.exceptions.ServiceUnavailableException;
 import uk.gov.companieshouse.pscdataapi.models.PscDeleteRequest;
@@ -27,6 +29,8 @@
 @Service
 public class ChsKafkaApiService {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(APPLICATION_NAME_SPACE);
+
     private static final String RESOURCE_CHANGED_URI = "/private/resource-changed";
     private static final String PSC_URI = "/company/%s/persons-with-significant-control/%s/%s";
     private static final String CHANGED_EVENT_TYPE = "changed";
@@ -36,15 +40,12 @@ public class ChsKafkaApiService {
 
     private final CompanyPscTransformer companyPscTransformer;
     private final Supplier<InternalApiClient> kafkaApiClientSupplier;
-    private final Logger logger;
     private final ObjectMapper objectMapper;
 
     public ChsKafkaApiService(CompanyPscTransformer companyPscTransformer,
-            @Qualifier("kafkaApiClientSupplier") Supplier<InternalApiClient> kafkaApiClientSupplier, Logger logger,
-            ObjectMapper objectMapper) {
+            @Qualifier("kafkaApiClientSupplier") Supplier<InternalApiClient> kafkaApiClientSupplier, ObjectMapper objectMapper) {
         this.companyPscTransformer = companyPscTransformer;
         this.kafkaApiClientSupplier = kafkaApiClientSupplier;
-        this.logger = logger;
         this.objectMapper = objectMapper;
     }
 
@@ -133,12 +134,13 @@ private static String mapKind(String kind) {
     private ApiResponse<Void> handleApiCall(PrivateChangedResourcePost changedResourcePost) {
         try {
             return changedResourcePost.execute();
-        } catch (ApiErrorResponseException exception) {
-            logger.error("Unsuccessful call to /resource-changed endpoint", exception);
-            throw new ServiceUnavailableException(exception.getMessage());
-        } catch (RuntimeException exception) {
-            logger.error("Error occurred while calling /resource-changed endpoint", exception);
-            throw exception;
+        } catch (ApiErrorResponseException ex) {
+            final String msg = "Unsuccessful call to resource-changed endpoint";
+            LOGGER.error(msg, ex);
+            throw new ServiceUnavailableException(msg);
+        } catch (RuntimeException ex) {
+            LOGGER.error("Error occurred while calling resource-changed endpoint", ex);
+            throw ex;
         }
     }
 

src/main/java/uk/gov/companieshouse/pscdataapi/api/ResourceChangedApiServiceAspect.java

@@ -1,24 +1,28 @@
 package uk.gov.companieshouse.pscdataapi.api;
 
+import static uk.gov.companieshouse.pscdataapi.PscDataApiApplication.APPLICATION_NAME_SPACE;
+
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.stereotype.Component;
 import uk.gov.companieshouse.logging.Logger;
+import uk.gov.companieshouse.logging.LoggerFactory;
 import uk.gov.companieshouse.pscdataapi.config.FeatureFlags;
+import uk.gov.companieshouse.pscdataapi.logging.DataMapHolder;
 
 @Aspect
 @Component
 @ConditionalOnProperty(prefix = "feature", name = "seeding_collection_enabled")
 public class ResourceChangedApiServiceAspect {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(APPLICATION_NAME_SPACE);
+
     private final FeatureFlags featureFlags;
-    private final Logger logger;
 
-    public ResourceChangedApiServiceAspect(FeatureFlags featureFlags, Logger logger) {
+    public ResourceChangedApiServiceAspect(FeatureFlags featureFlags) {
         this.featureFlags = featureFlags;
-        this.logger = logger;
     }
 
     /**
@@ -32,10 +36,10 @@ public ResourceChangedApiServiceAspect(FeatureFlags featureFlags, Logger logger)
     public Object invokeChsKafkaApi(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
 
         if (featureFlags.isStreamHookDisabled()) {
-            logger.debug("Stream hook disabled; not publishing change to chs-kafka-api");
+            LOGGER.debug("Stream hook disabled; not publishing change to chs-kafka-api", DataMapHolder.getLogMap());
             return null;
         } else {
-            logger.debug("Stream hook enabled; publishing change to chs-kafka-api");
+            LOGGER.debug("Stream hook enabled; publishing change to chs-kafka-api", DataMapHolder.getLogMap());
             return proceedingJoinPoint.proceed();
         }
     }

src/main/java/uk/gov/companieshouse/pscdataapi/config/ExceptionHandlerConfig.java

@@ -1,11 +1,12 @@
 package uk.gov.companieshouse.pscdataapi.config;
 
+import static uk.gov.companieshouse.pscdataapi.PscDataApiApplication.APPLICATION_NAME_SPACE;
+
 import com.mongodb.MongoException;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeParseException;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.dao.DataAccessException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -16,6 +17,7 @@
 import org.springframework.web.context.request.WebRequest;
 import org.springframework.web.servlet.NoHandlerFoundException;
 import uk.gov.companieshouse.logging.Logger;
+import uk.gov.companieshouse.logging.LoggerFactory;
 import uk.gov.companieshouse.pscdataapi.exceptions.BadGatewayException;
 import uk.gov.companieshouse.pscdataapi.exceptions.BadRequestException;
 import uk.gov.companieshouse.pscdataapi.exceptions.ConflictException;
@@ -26,13 +28,7 @@
 @ControllerAdvice
 public class ExceptionHandlerConfig {
 
-    private final Logger logger;
-
-    @Autowired
-    public ExceptionHandlerConfig(Logger logger) {
-        this.logger = logger;
-    }
-
+    private static final Logger LOGGER = LoggerFactory.getLogger(APPLICATION_NAME_SPACE);
     private static final String TIMESTAMP = "timestamp";
     private static final String MESSAGE = "message";
     private static final String EXCEPTION_ATTRIBUTE = "javax.servlet.error.exception";
@@ -46,8 +42,7 @@ public ExceptionHandlerConfig(Logger logger) {
      */
     @ExceptionHandler(value = {Exception.class, SerDesException.class})
     public ResponseEntity<Object> handleException(Exception ex, WebRequest request) {
-        logger.error(String.format("Unexpected exception, response code: %s",
-                HttpStatus.INTERNAL_SERVER_ERROR), ex);
+        LOGGER.error("Unexpected exception, response code: %s".formatted(HttpStatus.INTERNAL_SERVER_ERROR), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());
@@ -65,8 +60,7 @@ public ResponseEntity<Object> handleException(Exception ex, WebRequest request)
      */
     @ExceptionHandler(value = {IllegalArgumentException.class, NoHandlerFoundException.class})
     public ResponseEntity<Object> handleNotFoundException(Exception ex, WebRequest request) {
-        logger.error(String.format("Resource not found, response code: %s",
-                HttpStatus.NOT_FOUND), ex);
+        LOGGER.error("Resource not found, response code: %s".formatted(HttpStatus.NOT_FOUND), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());
@@ -84,10 +78,8 @@ public ResponseEntity<Object> handleNotFoundException(Exception ex, WebRequest r
      */
     @ExceptionHandler(value = {MethodNotAllowedException.class,
             HttpRequestMethodNotSupportedException.class})
-    public ResponseEntity<Object> handleMethodNotAllowedException(
-            Exception ex, WebRequest request) {
-        logger.error(String.format("Unable to process the request, response code: %s",
-                HttpStatus.METHOD_NOT_ALLOWED), ex);
+    public ResponseEntity<Object> handleMethodNotAllowedException(Exception ex, WebRequest request) {
+        LOGGER.error("Method not allowed, response code: %s".formatted(HttpStatus.METHOD_NOT_ALLOWED), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());
@@ -107,8 +99,7 @@ public ResponseEntity<Object> handleMethodNotAllowedException(
             DataAccessException.class, MongoException.class})
     public ResponseEntity<Object> handleServiceUnavailableException(Exception ex,
             WebRequest request) {
-        logger.error(String.format("Service unavailable, response code: %s",
-                HttpStatus.SERVICE_UNAVAILABLE), ex);
+        LOGGER.error("Service unavailable, response code: %s".formatted(HttpStatus.SERVICE_UNAVAILABLE), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());
@@ -127,7 +118,7 @@ public ResponseEntity<Object> handleServiceUnavailableException(Exception ex,
     @ExceptionHandler(value = {BadRequestException.class, DateTimeParseException.class,
             HttpMessageNotReadableException.class})
     public ResponseEntity<Object> handleBadRequestException(Exception ex, WebRequest request) {
-        logger.error(String.format("Bad request, response code: %s", HttpStatus.BAD_REQUEST), ex);
+        LOGGER.error("Bad request, response code: %s".formatted(HttpStatus.BAD_REQUEST), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());
@@ -146,7 +137,7 @@ public ResponseEntity<Object> handleBadRequestException(Exception ex, WebRequest
      */
     @ExceptionHandler(value = {ConflictException.class})
     public ResponseEntity<Object> handleConflictException(Exception ex, WebRequest request) {
-        logger.error(String.format("Conflict, response code: %s", HttpStatus.CONFLICT), ex);
+        LOGGER.error("Conflict, response code: %s".formatted(HttpStatus.CONFLICT), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());
@@ -157,7 +148,7 @@ public ResponseEntity<Object> handleConflictException(Exception ex, WebRequest r
 
     @ExceptionHandler(value = {BadGatewayException.class})
     public ResponseEntity<Object> handleBadGatewayException(Exception ex, WebRequest request) {
-        logger.error(String.format("Bad Gateway, response code: %s", HttpStatus.BAD_GATEWAY), ex);
+        LOGGER.error("Bad Gateway, response code: %s".formatted(HttpStatus.BAD_GATEWAY), ex);
 
         Map<String, Object> responseBody = new LinkedHashMap<>();
         responseBody.put(TIMESTAMP, LocalDateTime.now());