Merge "logging requests and responses in SyncRestClient"

diff --combined vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
index 398d81d,f708756..5c65c8a
--- 1/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
--- 2/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
+++ b/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
@@@ -21,8 -21,8 +21,8 @@@
  
  package org.onap.vid.client;
  
 -import static org.apache.commons.lang3.StringUtils.isEmpty;
  import static org.onap.vid.client.UnirestPatchKt.patched;
 +import static org.onap.vid.utils.KotlinUtilsKt.JOSHWORKS_JACKSON_OBJECT_MAPPER;
  
  import com.att.eelf.configuration.EELFLogger;
  import io.joshworks.restclient.http.HttpResponse;
@@@ -55,6 -55,7 +55,7 @@@ import org.onap.portalsdk.core.logging.
  import org.onap.portalsdk.core.util.SystemProperties;
  import org.onap.vid.properties.VidProperties;
  import org.onap.vid.utils.Logging;
+ import org.springframework.http.HttpMethod;
  
  public class SyncRestClient implements SyncRestClientInterface {
      private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(SyncRestClient.class);
@@@ -90,68 -91,133 +91,133 @@@
  
      @Override
      public HttpResponse<JsonNode> post(String url, Map<String, String> headers, Object body) {
-         return callWithRetryOverHttp(url, url2 -> restClient.post(url2).headers(headers).body(body).asJson());
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.POST, url, body);
+ 
+         HttpResponse<JsonNode> response = callWithRetryOverHttp(url,
+             url2 -> restClient.post(url2).headers(headers).body(body).asJson());
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.POST, url, response);
+ 
+         return response;
      }
  
      @Override
      public <T> HttpResponse<T> post(String url, Map<String, String> headers, Object body, Class<T> responseClass) {
-         return callWithRetryOverHttp(url,
-                 url2 -> restClient.post(url2).headers(headers).body(body).asObject(responseClass));
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.POST, url, body);
+ 
+         HttpResponse<T> response = callWithRetryOverHttp(url,
+             url2 -> restClient.post(url2).headers(headers).body(body).asObject(responseClass));
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.POST, url, response);
+ 
+         return response;
      }
  
      @Override
      public HttpResponse<JsonNode> get(String url, Map<String, String> headers, Map<String, String> routeParams) {
-         return callWithRetryOverHttp(url, url2 -> {
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url, routeParams);
+ 
+         HttpResponse<JsonNode> response = callWithRetryOverHttp(url, url2 -> {
              GetRequest getRequest = restClient.get(url2).headers(headers);
              routeParams.forEach(getRequest::routeParam);
              return getRequest.asJson();
          });
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, response);
+ 
+         return response;
      }
  
      @Override
      public <T> HttpResponse<T> get(String url, Map<String, String> headers, Map<String, String> routeParams,
                                     Class<T> responseClass) {
-         return callWithRetryOverHttp(url, url2 -> {
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url, routeParams);
+ 
+         HttpResponse<T> response = callWithRetryOverHttp(url, url2 -> {
              GetRequest getRequest = restClient.get(url2).headers(headers);
              routeParams.forEach(getRequest::routeParam);
              return getRequest.asObject(responseClass);
          });
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, response);
+ 
+         return response;
      }
  
      @Override
      public HttpResponse<InputStream> getStream(String url, Map<String, String> headers,
                                                 Map<String, String> routeParams) {
-         return callWithRetryOverHttp(url, url2 -> {
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url, routeParams);
+ 
+         HttpResponse<InputStream> response = callWithRetryOverHttp(url, url2 -> {
              GetRequest getRequest = restClient.get(url2).headers(headers);
              routeParams.forEach(getRequest::routeParam);
              return getRequest.asBinary();
          });
+ 
+         //no logging of the response since the response is too long
+         return response;
+ 
      }
  
      @Override
      public HttpResponse<JsonNode> put(String url, Map<String, String> headers, Object body) {
-         return callWithRetryOverHttp(url, url2 -> restClient.put(url2).headers(headers).body(body).asJson());
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.PUT, url, body);
+ 
+         HttpResponse<JsonNode> response = callWithRetryOverHttp(url,
+             url2 -> restClient.put(url2).headers(headers).body(body).asJson());
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.PUT, url, response);
+ 
+         return response;
      }
  
      @Override
      public <T> HttpResponse<T> put(String url, Map<String, String> headers, Object body, Class<T> responseClass) {
-         return callWithRetryOverHttp(url,
-                 url2 -> restClient.put(url2).headers(headers).body(body).asObject(responseClass));
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.PUT, url, body);
+ 
+         HttpResponse<T> response = callWithRetryOverHttp(url,
+             url2 -> restClient.put(url2).headers(headers).body(body).asObject(responseClass));
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.PUT, url, response);
+ 
+         return response;
      }
  
      @Override
      public <T> HttpResponse<T> delete(String url, Map<String, String> headers, Object body, Class<T> responseClass) {
-         return callWithRetryOverHttp(url, url2 -> restClient.delete(url2).headers(headers).body(body).asObject(responseClass));
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url, body);
+ 
+         HttpResponse<T> response = callWithRetryOverHttp(url,
+             url2 -> restClient.delete(url2).headers(headers).body(body).asObject(responseClass));
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, response);
+ 
+         return response;
      }
  
      @Override
      public <T> HttpResponse<T> delete(String url, Map<String, String> headers, Class<T> responseClass) {
-         return callWithRetryOverHttp(url, url2 -> restClient.delete(url2).headers(headers).asObject(responseClass));
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url);
+ 
+         HttpResponse<T> response = callWithRetryOverHttp(url,
+             url2 -> restClient.delete(url2).headers(headers).asObject(responseClass));
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, response);
+ 
+         return response;
      }
  
      @Override
      public HttpResponse<JsonNode> delete(String url, Map<String, String> headers) {
-         return callWithRetryOverHttp(url, url2 -> restClient.delete(url2).headers(headers).asJson());
+         loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url);
+ 
+         HttpResponse<JsonNode> response = callWithRetryOverHttp(url,
+             url2 -> restClient.delete(url2).headers(headers).asJson());
+ 
+         loggingService.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, response);
+ 
+         return response;
      }
  
      @Override
@@@ -172,7 -238,7 +238,7 @@@
              return patched(httpRequest.apply(url));
          } catch (RestClientException e) {
              if (causedBySslHandshakeError(e)) {
-                 logger.warn(EELFLoggerDelegate.debugLogger, "SSL Handshake problem occured. Will try to retry over Http.", e);
+                 logger.warn("SSL Handshake problem occured. Will try to retry over Http.", e);
                  return patched(httpRequest.apply(url.replaceFirst(HTTPS_SCHEMA, HTTP_SCHEMA)));
              }
              throw e;
@@@ -184,7 -250,27 +250,7 @@@
      }
  
      private ObjectMapper defaultObjectMapper() {
 -        com.fasterxml.jackson.databind.ObjectMapper objectMapper = new com.fasterxml.jackson.databind.ObjectMapper();
 -
 -        return new ObjectMapper() {
 -            @Override
 -            public <T> T readValue(String value, Class<T> aClass) {
 -                try {
 -                    return isEmpty(value) ? null : objectMapper.readValue(value, aClass);
 -                } catch (IOException e) {
 -                    throw new SyncRestClientException("IOException while reading value", e);
 -                }
 -            }
 -
 -            @Override
 -            public String writeValue(Object value) {
 -                try {
 -                    return objectMapper.writeValueAsString(value);
 -                } catch (IOException e) {
 -                    throw new SyncRestClientException("IOException while writing value", e);
 -                }
 -            }
 -        };
 +        return JOSHWORKS_JACKSON_OBJECT_MAPPER;
      }
  
      private CloseableHttpClient defaultHttpClient() {
@@@ -199,7 -285,7 +265,7 @@@
  
              return HttpClients.custom().setSSLSocketFactory(sslSf).build();
          } catch (IOException | CertificateException | UnrecoverableKeyException | NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
-             logger.warn(EELFLoggerDelegate.debugLogger, "Cannot initialize custom http client from current configuration. Using default one.", e);
+             logger.warn("Cannot initialize custom http client from current configuration. Using default one.", e);
              return HttpClients.createDefault();
          }
      }