Restyle added logging, added coverall after removing it because of issue in server of coverall

.circleci/config.yml

@@ -52,7 +52,7 @@ jobs:
             coverage report -m
             mkdir ../test-reports
             coverage html -d ../test-reports
-#            COVERALLS_REPO_TOKEN=${COVERALLS_REPO_TOKEN} coveralls
+            COVERALLS_REPO_TOKEN=${COVERALLS_REPO_TOKEN} coveralls
       - store_test_results:
           path: test-reports
       - store_artifacts:

metering/handlers/freecall_handler.py

@@ -1,47 +1,45 @@
-import json
-import logging
-
-from constants import StatusCode, StatusMessage, HEADER_POST_RESPONSE
+from constants import HEADER_POST_RESPONSE
+from constants import StatusCode
+from constants import StatusMessage
+from logger import get_logger
 from services import UsageService
-from logger import setup_logger
-from utils import validate_request, make_response
+
+from utils import generate_lambda_response
+from utils import validate_request
 
 usage_service = UsageService()
 
-setup_logger()
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
-required_keys = ['organization_id', 'service_id']
+required_keys = ["organization_id", "service_id"]
 
 
 def main(event, context):
-    if validate_request(required_keys, event['queryStringParameters']):
-        try:
-            org_id = event['queryStringParameters']['organization_id']
-            service_id = event['queryStringParameters']['service_id']
-            username = event['queryStringParameters']['username']
+    logger.info("Free call request received")
+    try:
+        if validate_request(required_keys, event["queryStringParameters"]):
+            org_id = event["queryStringParameters"]["organization_id"]
+            service_id = event["queryStringParameters"]["service_id"]
+            username = event["queryStringParameters"]["username"]
+
+            logger.info(f"Fetched values from request \n"
+                        f"username: {username} \n"
+                        f"org_id: {org_id} \n"
+                        f"service_id: {service_id} \n")
+
             free_call_details = usage_service.get_free_call_details(
                 username, org_id, service_id)
-            return_value = make_response(
-                status_code=StatusCode.SUCCESS_GET_CODE,
-                header=HEADER_POST_RESPONSE,
-                body=json.dumps(free_call_details)
-            )
-
-        except Exception as e:
-            logger.error(e)
-            return_value = make_response(
-                status_code=StatusCode.SERVER_ERROR_CODE,
-                header=HEADER_POST_RESPONSE,
-                body=json.dumps({"error": StatusMessage.SERVER_ERROR_MSG})
-            )
-
-    else:
-        logger.error(f"Request validation failed for {event['queryStringParameters']}")
-        return_value = make_response(
-            status_code=StatusCode.BAD_PARAMETERS_CODE,
-            header=HEADER_POST_RESPONSE,
-            body=json.dumps({"error": StatusMessage.BAD_PARAMETER})
-        )
-
-    return return_value
+            response = free_call_details
+            status_code = StatusCode.SUCCESS_GET_CODE
+        else:
+            logger.error(f"Request validation failed")
+            logger.info(event)
+            response = StatusMessage.BAD_PARAMETER
+            status_code = StatusCode.BAD_PARAMETERS_CODE
+    except Exception as e:
+        logger.error("Failed to get free call details")
+        logger.info(event)
+        status_code = (StatusCode.SERVER_ERROR_CODE, )
+        response = StatusMessage.SERVER_ERROR_MSG
+
+    return generate_lambda_response(status_code, response)

metering/handlers/usage_handler.py

@@ -1,44 +1,53 @@
 import json
 import logging
 
-from constants import StatusCode, StatusMessage
-from logger import setup_logger
+from constants import StatusCode
+from constants import StatusMessage
+from logger import get_logger
 from services import UsageService
-from utils import validate_request, make_response, usage_record_add_verify_fields
+
+from utils import generate_lambda_response
+from utils import usage_record_add_verify_fields
+from utils import validate_request
 
 usage_service = UsageService()
 
-setup_logger()
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
-required_keys = ["organization_id", "service_id", "username", 'usage_value', 'usage_type',
-                 'service_method', 'group_id', 'status', 'start_time', 'end_time']
+required_keys = [
+    "organization_id",
+    "service_id",
+    "username",
+    "usage_value",
+    "usage_type",
+    "service_method",
+    "group_id",
+    "status",
+    "start_time",
+    "end_time",
+]
 
 
 def main(event, context):
-    request_dict = json.loads(event['body'])
-
+    logger.info("Usage record request received")
     try:
+        request_dict = json.loads(event["body"])
         if validate_request(required_keys, request_dict):
             usage_detail_dict = usage_record_add_verify_fields(request_dict)
-            print(f"usage record after modification: {usage_detail_dict}")
+            logging.info(
+                f"usage record after modification: {usage_detail_dict}")
             usage_service.save_usage_details(usage_detail_dict)
-            response = make_response(
-                StatusCode.SUCCESS_GET_CODE,
-                json.dumps({"status": StatusMessage.SUCCESS_POST_CODE})
-            )
+            response = "success"
+            status_code = StatusCode.SUCCESS_GET_CODE
         else:
-            logger.error(f'Request validation failed {request_dict}')
-            response = make_response(
-                StatusCode.BAD_PARAMETERS_CODE,
-                json.dumps({"status": StatusMessage.BAD_PARAMETER})
-            )
+            logger.error(f"Request validation failed")
+            logger.info(event)
+            response = StatusMessage.BAD_PARAMETER
+            status_code = StatusCode.BAD_PARAMETERS_CODE
     except Exception as e:
-        logger.error(e)
-        logger.error(f'failed for request {request_dict}')
-        response = make_response(
-            StatusCode.SERVER_ERROR_CODE,
-            json.dumps({"status": StatusMessage.SERVER_ERROR_MSG})
-        )
-
-    return response
+        logger.error("Failed to get free call details")
+        logger.info(event)
+        status_code = (StatusCode.SERVER_ERROR_CODE, )
+        response = StatusMessage.SERVER_ERROR_MSG
+
+    return generate_lambda_response(status_code, response)

metering/logger.py

@@ -1,12 +1,18 @@
-import logging.config
+import logging
+import sys
 
+FORMATTER = logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s")
 
-def setup_logger():
-    logging.basicConfig(
-        level=logging.INFO, format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
 
+def get_console_handler():
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(FORMATTER)
+    return console_handler
 
-if __name__ == '__main__':
-    setup_logger()
-    logger = logging.getLogger()
-    logger.info("hi, it is test")
+
+def get_logger(logger_name):
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.INFO)
+    logger.addHandler(get_console_handler())
+    logger.propagate = False
+    return logger

metering/repository/base_repository.py

@@ -1,17 +1,16 @@
 import os
 
+from settings import DB_URL
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-from settings import DB_URL
 
-engine = create_engine(DB_URL, echo=True)
+engine = create_engine(DB_URL, echo=False)
 
 Session = sessionmaker(bind=engine)
 default_session = Session()
 
 
 class BaseRepository(object):
-
     def get_default_session(self, session=None):
         if not session:
             return default_session

metering/serverless.yml

@@ -55,7 +55,7 @@ functions:
             arn: ${file(./config.${self:provider.stage}.json):SIGN_AUTHORIZER}
             identitySource: ${file(./config.${self:provider.stage}.json):SIGN_HEADERS}
             name: verify_authorizer
-#            resultTtlInSeconds: 100
+          #            resultTtlInSeconds: 100
           cors:
             origin: ${self:custom.origin.${self:provider.stage}}
             headers:
@@ -77,9 +77,6 @@ functions:
       subnetIds:
         - ${file(./config.${self:provider.stage}.json):VPC1}
         - ${file(./config.${self:provider.stage}.json):VPC2}
-    #    The following are a few example events you can configure
-    #    NOTE: Please make sure to change your handler code to work with those events
-    #    Check the event documentation for details
     events:
       - http:
           path: /usage/freecalls
@@ -89,7 +86,7 @@ functions:
             arn: ${file(./config.${self:provider.stage}.json):SIGN_AUTHORIZER}
             identitySource: ${file(./config.${self:provider.stage}.json):SIGN_HEADERS}
             name: freecall_authorizer
-#            resultTtlInSeconds: 100
+          #            resultTtlInSeconds: 100
           cors:
             origin: ${self:custom.origin.${self:provider.stage}}
             headers:
@@ -110,9 +107,6 @@ functions:
       subnetIds:
         - ${file(./config.${self:provider.stage}.json):VPC1}
         - ${file(./config.${self:provider.stage}.json):VPC2}
-    #    The following are a few example events you can configure
-    #    NOTE: Please make sure to change your handler code to work with those events
-    #    Check the event documentation for details
     events:
       - http:
           path: /usage
@@ -122,7 +116,7 @@ functions:
             arn: ${file(./config.${self:provider.stage}.json):SIGN_AUTHORIZER}
             identitySource: ${file(./config.${self:provider.stage}.json):SIGN_HEADERS}
             name: usage_authorizer
-#            resultTtlInSeconds: 100
+          #            resultTtlInSeconds: 100
           cors:
             origin: ${self:custom.origin.${self:provider.stage}}
             headers:

metering/services.py

@@ -1,65 +1,85 @@
 import json
-import logging
 
 import boto3 as boto3
-
-from settings import CONTRACT_API_ARN, CONTRACT_API_STAGE
+from logger import get_logger
+from settings import CONTRACT_API_ARN
+from settings import CONTRACT_API_STAGE
 from storage import DatabaseStorage
+
 from utils import is_free_call
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class UsageService(object):
     storage_service = DatabaseStorage()
 
-    def get_free_call_details(self, username, org_id, service_id, group_id=None):
+    def get_free_call_details(self,
+                              username,
+                              org_id,
+                              service_id,
+                              group_id=None):
         total_calls, free_calls = self.storage_service.get_usage_details(
             username, org_id, service_id, group_id)
 
+        logger.info(
+            f"Free calls allowed: {free_calls}, Total calls made: {total_calls}"
+        )
         if not free_calls:
             free_calls = 0
         if not total_calls:
             total_calls = 0
 
-        response = {"username": username, "org_id": org_id, "service_id": service_id, "total_calls_made": total_calls,
-                    "free_calls_allowed": free_calls}
+        response = {
+            "username": username,
+            "org_id": org_id,
+            "service_id": service_id,
+            "total_calls_made": total_calls,
+            "free_calls_allowed": free_calls,
+        }
 
         logger.info(response)
         return response
 
     def save_usage_details(self, usage_details_dict):
         # nedd to introduce entities when we enhance  feature to this service right now directly using dicts
         if not is_free_call(usage_details_dict):
-            channel_id = usage_details_dict['channel_id']
-            group_id = usage_details_dict['group_id']
-            user_address = APIUtilityService().get_user_address(group_id, channel_id)
-            usage_details_dict['user_address'] = user_address
+            logger.info("Received usage record request for paid call")
+            channel_id = usage_details_dict["channel_id"]
+            group_id = usage_details_dict["group_id"]
+
+            user_address = APIUtilityService().get_user_address(
+                group_id, channel_id)
+            usage_details_dict["user_address"] = user_address
+            logger.info(
+                f"fetched user address from contract api: {user_address}")
+
         self.storage_service.add_usage_data(usage_details_dict)
         return
 
 
 class APIUtilityService:
-
     def __init__(self):
-        self.lambda_client = boto3.client('lambda')
+        self.lambda_client = boto3.client("lambda")
 
     def get_user_address(self, group_id, channel_id):
         lambda_payload = {
             "httpMethod": "GET",
-            "requestContext": {"stage": CONTRACT_API_STAGE},
-            "path": f"/contract-api/group/{group_id}/channel/{channel_id}"
+            "requestContext": {
+                "stage": CONTRACT_API_STAGE
+            },
+            "path": f"/contract-api/group/{group_id}/channel/{channel_id}",
         }
 
         try:
+            logger.info(f"Calling contract api for user_address")
             response = self.lambda_client.invoke(
                 FunctionName=CONTRACT_API_ARN,
-                Payload=json.dumps(lambda_payload)
-            )
+                Payload=json.dumps(lambda_payload))
             response_body_raw = json.loads(
-                response.get('Payload').read())['body']
+                response.get("Payload").read())["body"]
             response_body = json.loads(response_body_raw)
-            user_address = response_body['data'][0]['sender']
+            user_address = response_body["data"][0]["sender"]
         except Exception as e:
             print(e)
             raise Exception("Failed to get user address from marketplace")