Resource level filter logging feature added

components/apimgt/org.wso2.carbon.apimgt.api/src/main/java/org/wso2/carbon/apimgt/api/ExceptionCodes.java

@@ -494,6 +494,7 @@ public enum ExceptionCodes implements ErrorHandler {
     LOGGING_API_NOT_FOUND(901400, "Requested Resource Not Found", 404, "Request API Not Found for context: %s"),
     LOGGING_API_INCORRECT_LOG_LEVEL(901401, "Bad Request", 400, "Log level should be either OFF, BASIC, STANDARD or FULL"),
     LOGGING_API_MISSING_DATA(901402, "Missing data", 400, "API context or log level is missing"),
+    LOGGING_API_RESOURCE_NOT_FOUND(901403, "Requested Resource Not Found", 400, "Requested API Resource Not Found"),
     CORRELATION_CONFIG_BAD_REQUEST(902020, "Bad Request", 400, "Request body can not have empty elements"),
     CORRELATION_CONFIG_BAD_REQUEST_INVALID_NAME(902021, "Bad Request", 400, "Request body contains invalid correlation component name"),
     //Service Catalog related error codes

components/apimgt/org.wso2.carbon.apimgt.devops.impl/src/main/java/org/wso2/carbon/apimgt/devops/impl/logging/APILoggingImpl.java

@@ -38,9 +38,13 @@
 public class APILoggingImpl {
     private static final String PER_API_LOGGING_PERMISSION_PATH = "/permission/protected/configure/logging";
     private static final String INVALID_LOGGING_PERMISSION = "Invalid logging permission";
+    private static final String INCORRECT_LOGGING_PER_API_RESOURCE_REQUEST = "Resource Method and Resource Path both " +
+            "should included";
+    private static final String REQUIRED_API_RESOURCE_IS_NOT_AVAILABLE = "Requested resource is not available";
     private final ApiMgtDAO apiMgtDAO = ApiMgtDAO.getInstance();
 
-    public void addUpdateAPILogger(String tenantId, String apiId, String logLevel) throws APIManagementException {
+    public void addUpdateAPILogger(String tenantId, String apiId, String logLevel, String resourceMethod,
+                                   String resourcePath) throws APIManagementException {
         if (apiMgtDAO.getAPIInfoByUUID(apiId) == null) {
             throw new APIManagementException("API not found.",
                     ExceptionCodes.from(ExceptionCodes.API_NOT_FOUND, apiId));
@@ -49,13 +53,29 @@ public void addUpdateAPILogger(String tenantId, String apiId, String logLevel) t
             throw new APIManagementException(INVALID_LOGGING_PERMISSION,
                     ExceptionCodes.from(ExceptionCodes.INVALID_PERMISSION));
         }
-        LoggingMgtDAO.getInstance().addAPILogger(tenantId, apiId, logLevel);
-        publishLogAPIData(tenantId, apiId, logLevel);
+        if (resourceMethod != null && resourcePath != null) {
+            boolean isAPIResourceExists = LoggingMgtDAO.getInstance().checkAPILoggerPerResourceAvailable(tenantId,
+                    apiId, resourceMethod.toUpperCase(), resourcePath);
+            if (isAPIResourceExists) {
+                LoggingMgtDAO.getInstance().addAPILoggerPerResource(tenantId, apiId, logLevel,
+                        resourceMethod.toUpperCase(), resourcePath);
+            } else {
+                throw new APIManagementException(REQUIRED_API_RESOURCE_IS_NOT_AVAILABLE,
+                        ExceptionCodes.from(ExceptionCodes.LOGGING_API_RESOURCE_NOT_FOUND));
+            }
+        } else if (resourceMethod == null && resourcePath == null) {
+            LoggingMgtDAO.getInstance().addAPILogger(tenantId, apiId, logLevel);
+        } else {
+            throw new APIManagementException(INCORRECT_LOGGING_PER_API_RESOURCE_REQUEST,
+                    ExceptionCodes.from(ExceptionCodes.LOGGING_API_MISSING_DATA));
+        }
+
+        publishLogAPIData(tenantId, apiId, logLevel, resourceMethod, resourcePath);
     }
 
-    private void publishLogAPIData(String tenantId, String apiId, String logLevel) throws APIManagementException {
+    private void publishLogAPIData(String tenantId, String apiId, String logLevel, String resourceMethod, String resourcePath) throws APIManagementException {
         APIEvent apiEvent = new APIEvent(apiId, logLevel, APIConstants.EventType.UDATE_API_LOG_LEVEL.name(),
-                apiMgtDAO.getAPIContext(apiId));
+                apiMgtDAO.getAPIContext(apiId), resourceMethod, resourcePath, tenantId);
         APIUtil.sendNotification(apiEvent, APIConstants.NotifierType.API.name());
     }
 

components/apimgt/org.wso2.carbon.apimgt.gateway/src/main/java/org/wso2/carbon/apimgt/gateway/APILoggerManager.java

@@ -46,7 +46,7 @@
  */
 public class APILoggerManager {
     private static final Log log = LogFactory.getLog(APILoggerManager.class);
-    private static final Map<String, String> logProperties = new HashMap<>();
+    private Map<Map<String, String>, String> logProperties = new HashMap<>();
     private static final APILoggerManager apiLoggerManager = new APILoggerManager();
     private final EventHubConfigurationDto eventHubConfigurationDto;
     public static final int RETRIEVAL_RETRIES = 15;
@@ -61,7 +61,17 @@ public void initializeAPILoggerList() {
             JSONArray apiLogArray = responseJson.getJSONArray("apis");
             for (int i = 0; i < apiLogArray.length(); i++) {
                 JSONObject apiLoggerObject = apiLogArray.getJSONObject(i);
-                logProperties.put(apiLoggerObject.getString("context"), apiLoggerObject.getString("logLevel"));
+                String resourceMethod = null;
+                String resourcePath = null;
+                if(!apiLoggerObject.isNull("resourceMethod") && !apiLoggerObject.isNull("resourcePath") ){
+                    resourceMethod = apiLoggerObject.getString("resourceMethod");
+                    resourcePath = apiLoggerObject.getString("resourcePath");
+                }
+                Map<String, String> properties = new HashMap<>();
+                properties.put("context", apiLoggerObject.getString("context"));
+                properties.put("resourceMethod", resourceMethod);
+                properties.put("resourcePath", resourcePath);
+                logProperties.put(properties, apiLoggerObject.getString("logLevel"));
             }
             if (log.isDebugEnabled()) {
                 log.debug("Response : " + responseString);
@@ -71,11 +81,15 @@ public void initializeAPILoggerList() {
         }
     }
 
-    public void updateLoggerMap(String apiContext, String logLevel) {
-        logProperties.put(apiContext, logLevel);
+    public void updateLoggerMap(String apiContext, String logLevel, String resourceMethod, String resourcePath) {
+        Map<String, String> properties = new HashMap<>();
+        properties.put("context", apiContext);
+        properties.put("resourcePath", resourcePath);
+        properties.put("resourceMethod", resourceMethod);
+        logProperties.put(properties, logLevel);
     }
 
-    public Map<String, String> getPerAPILoggerList() {
+    public Map<Map<String, String>, String> getPerAPILoggerList() {
         return logProperties;
     }
 

components/apimgt/org.wso2.carbon.apimgt.gateway/src/main/java/org/wso2/carbon/apimgt/gateway/handlers/LogUtils.java

@@ -18,13 +18,19 @@
 
 package org.wso2.carbon.apimgt.gateway.handlers;
 
+import org.apache.axis2.Constants;
 import org.apache.http.HttpHeaders;
 import org.apache.synapse.MessageContext;
+import org.apache.synapse.api.API;
+import org.apache.synapse.api.ApiUtils;
+import org.apache.synapse.api.Resource;
+import org.apache.synapse.api.dispatch.DispatcherHelper;
+import org.apache.synapse.api.dispatch.RESTDispatcher;
 import org.apache.synapse.core.axis2.Axis2MessageContext;
 import org.wso2.carbon.apimgt.gateway.APIMgtGatewayConstants;
 import org.wso2.carbon.apimgt.impl.APIConstants;
 
-import java.util.Map;
+import java.util.*;
 
 /**
  * Provides util methods for the LogsHandler
@@ -91,7 +97,7 @@ protected static String getElectedResource(org.apache.synapse.MessageContext mes
         return (String) messageContext.getProperty("API_ELECTED_RESOURCE");
     }
 
-    protected static String getResourceCacheKey(org.apache.synapse.MessageContext messageContext){
+    protected static String getResourceCacheKey(org.apache.synapse.MessageContext messageContext) {
         return (String) messageContext.getProperty("API_RESOURCE_CACHE_KEY");
     }
 
@@ -119,16 +125,99 @@ protected static String getTransportInURL(org.apache.synapse.MessageContext mess
         return transportInURL.substring(1);
     }
 
-    protected static String getMatchingLogLevel(MessageContext ctx, Map<String, String> logProperties) {
-        String apiCtx = LogUtils.getTransportInURL(ctx);
-        for (Map.Entry<String, String> entry : logProperties.entrySet()) {
-            String key = entry.getKey().substring(1);
-            if (apiCtx.startsWith(key + "/") || apiCtx.equals(key)) {
-                ctx.setProperty(LogsHandler.LOG_LEVEL, entry.getValue());
-                ctx.setProperty("API_TO", apiCtx);
-                return entry.getValue();
+    protected static String getMatchingLogLevel(MessageContext messageContext,
+                                          Map<Map<String, String>, String> logProperties) {
+        //initializing variables to store resource level logging
+        String apiLogLevel = null;
+        String resourceLogLevel = null;
+        String resourcePath = null;
+        String resourceMethod = null;
+        Resource selectedResource = null;
+        //obtain the selected API by context and path
+        API selectedApi = null;
+        Collection<API> apiSet = messageContext.getEnvironment().getSynapseConfiguration().getAPIs();
+        //identify the api
+        for (API api : apiSet) {
+            if (ApiUtils.identifyApi(api, messageContext)) {
+                selectedApi = api;
+                break;
             }
         }
-        return null;
+        String apiContext = ((Axis2MessageContext) messageContext).getAxis2MessageContext()
+                .getProperty("TransportInURL").toString();
+        String httpMethod = (String) ((Axis2MessageContext) messageContext).getAxis2MessageContext()
+                .getProperty(Constants.Configuration.HTTP_METHOD);
+
+        if (selectedApi != null) {
+            Utils.setSubRequestPath(selectedApi, messageContext);
+            //iterating through all the existing resources to match with the requesting method
+            Map<String, Resource> resourcesMap = selectedApi.getResourcesMap();
+            Set<Resource> acceptableResources = ApiUtils
+                    .getAcceptableResources(resourcesMap, messageContext);
+            if (!acceptableResources.isEmpty()) {
+                for (RESTDispatcher dispatcher : ApiUtils.getDispatchers()) {
+                    selectedResource = dispatcher.findResource(messageContext, acceptableResources);
+                    if (selectedResource != null) {
+                        DispatcherHelper helper = selectedResource.getDispatcherHelper();
+                        for (Map.Entry<Map<String, String>, String> entry : logProperties.entrySet()) {
+                            Map<String, String> key = entry.getKey();
+                            //if resource path is empty, proceeding with API level logs
+                            if (selectedApi.getContext().equals(key.get("context"))) {
+                                if (key.get("resourcePath") == null && key.get("resourceMethod") == null) {
+                                    apiLogLevel = entry.getValue();
+                                    //matching the methods first and then the resource path
+                                } else if (httpMethod.equals(key.get("resourceMethod"))) {
+                                    if (helper.getString().equals(key.get("resourcePath"))) {
+                                        resourceLogLevel = entry.getValue();
+                                        resourcePath = key.get("resourcePath");
+                                        resourceMethod = key.get("resourceMethod");
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        boolean isResourceLevelHasHighPriority = false;
+        if (resourceLogLevel != null) {
+            switch (resourceLogLevel) {
+                case APIConstants.LOG_LEVEL_FULL:
+                    isResourceLevelHasHighPriority = true;
+                    break;
+                case APIConstants.LOG_LEVEL_STANDARD:
+                    if (apiLogLevel != null && (apiLogLevel.equals(APIConstants.LOG_LEVEL_BASIC)
+                            || apiLogLevel.equals(APIConstants.LOG_LEVEL_OFF))) {
+                        isResourceLevelHasHighPriority = true;
+                        break;
+                    } else {
+                        break;
+                    }
+                case APIConstants.LOG_LEVEL_BASIC:
+                    if (apiLogLevel == null || apiLogLevel.equals(APIConstants.LOG_LEVEL_OFF)) {
+                        isResourceLevelHasHighPriority = true;
+                    } else {
+                        break;
+                    }
+            }
+            if (isResourceLevelHasHighPriority || apiLogLevel == null) {
+                messageContext.setProperty(LogsHandler.LOG_LEVEL, resourceLogLevel);
+                messageContext.setProperty(LogsHandler.RESOURCE_PATH, resourcePath);
+                messageContext.setProperty(LogsHandler.RESOURCE_METHOD, resourceMethod);
+                messageContext.setProperty("API_TO", apiContext);
+                return resourceLogLevel;
+            } else {
+                messageContext.setProperty(LogsHandler.LOG_LEVEL, apiLogLevel);
+                messageContext.setProperty("API_TO", apiContext);
+                return apiLogLevel;
+            }
+        } else if (apiLogLevel != null) {
+            messageContext.setProperty(LogsHandler.LOG_LEVEL, apiLogLevel);
+            messageContext.setProperty("API_TO", apiContext);
+            return apiLogLevel;
+        } else {
+            return null;
+        }
     }
+
 }

components/apimgt/org.wso2.carbon.apimgt.gateway/src/main/java/org/wso2/carbon/apimgt/gateway/handlers/LogsHandler.java

@@ -54,7 +54,8 @@ public class LogsHandler extends AbstractSynapseHandler {
     private static final String UUID_HEADER = "UUID_HEADER";
     private static final String CORRELATION_ID_HEADER = "CORRELATION_ID_HEADER";
     protected static final String LOG_LEVEL = "LOG_LEVEL";
-
+    protected static final String RESOURCE_PATH = "RESOURCE_PATH";
+    protected static final String RESOURCE_METHOD = "RESOURCE_METHOD";
     private static final String REQUEST_BODY_SIZE_ERROR = "Error occurred while building the message to calculate" +
             " the response body size";
     private static final String REQUEST_EVENT_PUBLICATION_ERROR = "Cannot publish request event. ";
@@ -278,7 +279,7 @@ private long buildResponseMessage(org.apache.synapse.MessageContext messageConte
      *
      * @param map Map containing API context and logLevel
      */
-    public static Map<String, String> syncAPILogData(Map<String, Object> map) {
+    public static Map<Map<String, String>, String> syncAPILogData(Map<String, Object> map) {
         String apictx = (String) map.get("context");
         String logLevel = (String) map.get("value");
         log.debug("Log level for " + apictx + " is changed to " + logLevel);
@@ -288,7 +289,7 @@ public static String getLogData(String context) {
         return APILoggerManager.getInstance().getPerAPILoggerList().get(context);
     }
 
-    public static Map<String, String> getLogData() {
+    public static Map<Map<String, String>, String> getLogData() {
         return APILoggerManager.getInstance().getPerAPILoggerList();
     }
 
@@ -299,10 +300,11 @@ public static Map<String, String> getLogData() {
      * @return log level of the API or null if not
      */
     private String getAPILogLevel(MessageContext ctx) {
-        Map<String, String> logProperties = APILoggerManager.getInstance().getPerAPILoggerList();
+        Map<Map<String, String>, String> logProperties = APILoggerManager.getInstance().getPerAPILoggerList();
         // if the logging API data holder is empty or null return null
         if (!logProperties.isEmpty()) {
             return LogUtils.getMatchingLogLevel(ctx, logProperties);
+            //return LogUtils.getMatchingLogLevel(ctx, logProperties);
         }
         return null;
     }

components/apimgt/org.wso2.carbon.apimgt.gateway/src/main/java/org/wso2/carbon/apimgt/gateway/handlers/Utils.java

@@ -41,6 +41,7 @@
 import org.apache.synapse.SynapseConstants;
 import org.apache.synapse.api.API;
 import org.apache.synapse.api.ApiUtils;
+import org.apache.synapse.api.Resource;
 import org.apache.synapse.commons.json.JsonUtil;
 import org.apache.synapse.config.xml.rest.VersionStrategyFactory;
 import org.apache.synapse.core.axis2.Axis2MessageContext;
@@ -676,4 +677,65 @@ public static X509Certificate convertCertificateToX509Certificate(Certificate ce
         }
         return null;
     }
+
+    /**
+     * Using the api context to match API path to get the invoked API from an API Collection.
+     *
+     * @param messageContext MessageContext
+     * @return selected API based on the API path
+     */
+    public static API getAPIByContext(MessageContext messageContext) {
+        API selectedApi = null;
+        //getting the API collection from the synapse configuration to find the invoked API
+        Collection<API> apiSet = messageContext.getEnvironment().getSynapseConfiguration().getAPIs();
+        List<API> duplicateApiSet = new ArrayList<>(apiSet);
+        //obtaining required parameters to execute findResource method
+        String requestPath = ApiUtils.getFullRequestPath(messageContext);
+        for (API api : duplicateApiSet) {
+            if (ApiUtils.matchApiPath(requestPath, api.getContext())) {
+                selectedApi = api;
+                break;
+            }
+        }
+        return selectedApi;
+    }
+
+    /**
+     * Select acceptable resources from the set of all resources based on requesting methods.
+     *
+     * @return set of acceptable resources
+     */
+    public static Set<Resource> getAcceptableResources(Resource[] allAPIResources,
+                                                       String httpMethod, String corsRequestMethod) {
+        Set<Resource> acceptableResources = new LinkedHashSet<>();
+        for (Resource resource : allAPIResources) {
+            //If the requesting method is OPTIONS or if the Resource contains the requesting method
+            String [] resourceMethods = resource.getMethods();
+            if ((RESTConstants.METHOD_OPTIONS.equals(httpMethod) && resourceMethods != null
+                    && Arrays.asList(resourceMethods).contains(corsRequestMethod))
+                    || (resourceMethods != null && Arrays.asList(resourceMethods).contains(httpMethod))) {
+                acceptableResources.add(resource);
+            }
+        }
+        return acceptableResources;
+    }
+
+    /**
+     * Obtain the selected resource from the message context for CORSRequestHandler.
+     *
+     * @return selected resource
+     */
+    public static Resource getSelectedResource(MessageContext messageContext,
+                                               String httpMethod, String corsRequestMethod) {
+        Resource selectedResource = null;
+        Resource resource = (Resource) messageContext.getProperty(RESTConstants.SELECTED_RESOURCE);
+        String [] resourceMethods = resource.getMethods();
+        if ((RESTConstants.METHOD_OPTIONS.equals(httpMethod) && resourceMethods != null
+                && Arrays.asList(resourceMethods).contains(corsRequestMethod))
+                || (resourceMethods != null && Arrays.asList(resourceMethods).contains(httpMethod))) {
+            selectedResource = resource;
+        }
+        return selectedResource;
+    }
+
 }