X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=vid-app-common%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fvid%2Fclient%2FSyncRestClient.java;h=0883b3084ddeaffa946e8edb61256db5a8dd58fd;hb=e8d29ab5e3775472f59a4997fa3a5df9319de306;hp=398d81dfb4c49d56b82c42d02dcd5f97cc072f62;hpb=2609cc76f0565466667fff8ae4d0707b94993877;p=vid.git

diff --git a/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
index 398d81dfb..0883b3084 100644
--- a/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
@@ -49,12 +49,16 @@ import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
 import org.apache.http.conn.ssl.SSLContexts;
 import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
 import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.impl.client.HttpClients;
 import org.eclipse.jetty.util.security.Password;
 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
 import org.onap.portalsdk.core.util.SystemProperties;
+import org.onap.vid.logging.ApacheClientMetricRequestInterceptor;
+import org.onap.vid.logging.ApacheClientMetricResponseInterceptor;
 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);
@@ -67,22 +71,29 @@ public class SyncRestClient implements SyncRestClientInterface {
     private RestClient restClient;
 
     public SyncRestClient(Logging loggingService) {
-        this(null, null, loggingService);
+        this(null, null, loggingService, false);
+    }
+
+    public SyncRestClient(Logging loggingService, boolean useLoggingInterceptor) {
+        this(null, null, loggingService, useLoggingInterceptor);
     }
 
     public SyncRestClient(ObjectMapper objectMapper, Logging loggingService) {
-        this(null, objectMapper,  loggingService);
+        this(null, objectMapper,  loggingService, false);
     }
 
     public SyncRestClient(CloseableHttpClient httpClient, Logging loggingService) {
-        this(httpClient, null,  loggingService);
+        this(httpClient, null,  loggingService, false);
     }
 
-    public SyncRestClient(CloseableHttpClient httpClient, ObjectMapper objectMapper, Logging loggingService) {
+    public SyncRestClient(CloseableHttpClient httpClient,
+        ObjectMapper objectMapper,
+        Logging loggingService,
+        boolean useLoggingInterceptor) {
         restClient = RestClient
             .newClient()
             .objectMapper(ObjectUtils.defaultIfNull(objectMapper, defaultObjectMapper()))
-            .httpClient(ObjectUtils.defaultIfNull(httpClient , defaultHttpClient()))
+            .httpClient(ObjectUtils.defaultIfNull(httpClient , defaultHttpClient(useLoggingInterceptor)))
             .build();
         this.loggingService = loggingService;
         this.outgoingRequestsLogger = Logging.getRequestsLogger("syncRestClient");
@@ -90,68 +101,133 @@ public class SyncRestClient implements SyncRestClientInterface {
 
     @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 +248,7 @@ public class SyncRestClient implements SyncRestClientInterface {
             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;
@@ -187,7 +263,7 @@ public class SyncRestClient implements SyncRestClientInterface {
         return JOSHWORKS_JACKSON_OBJECT_MAPPER;
     }
 
-    private CloseableHttpClient defaultHttpClient() {
+    private CloseableHttpClient defaultHttpClient(boolean useLoggingInterceptor) {
         try {
             String trustStorePath = SystemProperties.getProperty(VidProperties.VID_TRUSTSTORE_FILENAME);
             String trustStorePass = SystemProperties.getProperty(VidProperties.VID_TRUSTSTORE_PASSWD_X);
@@ -197,9 +273,15 @@ public class SyncRestClient implements SyncRestClientInterface {
             SSLContext sslContext = trustOwnCACerts(decryptedTrustStorePass, trustStore);
             SSLConnectionSocketFactory sslSf = allowTLSProtocols(sslContext);
 
-            return HttpClients.custom().setSSLSocketFactory(sslSf).build();
+            HttpClientBuilder httpClientBuilder = HttpClients.custom().setSSLSocketFactory(sslSf);
+            if (useLoggingInterceptor) {
+                httpClientBuilder
+                    .addInterceptorFirst(new ApacheClientMetricRequestInterceptor())
+                    .addInterceptorLast(new ApacheClientMetricResponseInterceptor());
+            }
+            return httpClientBuilder.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();
         }
     }