Resource level filter logging feature added

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

@@ -498,6 +498,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

@@ -45,7 +45,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 String UTF8 = "UTF-8";
@@ -58,7 +58,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);
@@ -68,11 +78,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;
+ }
+
 }