feat: Add debug logger (#11)

SDK Clients can enable/disable logs using:

1. logging.ini
or
2. By adding following lines of code to their application

```
logger = logging.getLogger('momentosdk')
logger.setLevel(logging.DEBUG)

consoleHandler = logging.StreamHandler()
consoleHandler.setLevel(logging.DEBUG)
logger.addHandler(consoleHandler)
formatter = logging.Formatter('%(asctime)s  %(name)s  %(levelname)s: %(message)s')
consoleHandler.setFormatter(formatter)
```

Author: gautamomento

src/momento/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logging.getLogger('momentosdk').addHandler(logging.NullHandler())

src/momento/_cache_service_errors_converter.py

@@ -1,5 +1,6 @@
 import grpc
 from . import errors
+from . import _momento_logger
 from momento_wire_types import cacheclient_pb2 as cache_client_types
 
 __rpc_to_error = {
@@ -30,6 +31,7 @@ def convert(exception):
 
 
 def convert_ecache_result(ecache_result, message):
+    _momento_logger.debug(f'Converting ECacheResult: {ecache_result} to error.')
     if (ecache_result in __ecache_result_to_error):
         return __ecache_result_to_error[ecache_result](message)
     return errors.InternalServerError(

src/momento/_momento_logger.py

@@ -0,0 +1,8 @@
+import logging
+
+logger = logging.getLogger("momentosdk")
+def info(msg):
+    logger.info(msg)
+
+def debug(msg):
+    logger.debug(msg)

src/momento/cache.py

@@ -9,6 +9,7 @@
 from . import _cache_name_interceptor
 from . import errors
 from . import cache_operation_responses as cache_sdk_resp
+from . import _momento_logger
 
 
 class Cache:
@@ -32,9 +33,12 @@ def __init__(self, auth_token, cache_name, endpoint, default_ttlSeconds):
     # resource management for calls that need get or create functionality.
     def _connect(self) :
         try:
+            _momento_logger.debug('Initializing connection with Cache Service')
             self.get(uuid.uuid1().bytes)
+            _momento_logger.debug('Success: Connection Initialized with Cache Service')
             return self
         except Exception as e:
+            _momento_logger.debug(f'Cache Service Connect Failed with: {e}')
             raise _cache_service_errors_converter.convert(e) from None
 
     def __enter__(self):
@@ -45,6 +49,7 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
 
     def set(self, key, value, ttl_seconds=None):
         try:
+            _momento_logger.debug(f'Issuing a set request with key {key}')
             item_ttl_seconds = self._default_ttlSeconds if ttl_seconds is None else ttl_seconds
             self._validate_ttl(item_ttl_seconds)
             set_request = cache_client_types.SetRequest()
@@ -54,19 +59,24 @@ def set(self, key, value, ttl_seconds=None):
                 value, 'Unsupported type for value: ')
             set_request.ttl_milliseconds = item_ttl_seconds * 1000
             response = self._client.Set(set_request)
+            _momento_logger.debug(f'Set succeeded for key: {key}')
             return cache_sdk_resp.CacheSetResponse(response,
                                                    set_request.cache_body)
         except Exception as e:
+            _momento_logger.debug(f'Set failed for {key} with response: {e}')
             raise _cache_service_errors_converter.convert(e)
 
     def get(self, key):
         try:
+            _momento_logger.debug(f'Issuing a get request with key {key}')
             get_request = cache_client_types.GetRequest()
             get_request.cache_key = self._asBytes(
                 key, 'Unsupported type for key: ')
             response = self._client.Get(get_request)
+            _momento_logger.debug(f'Received a get response for {key}')
             return cache_sdk_resp.CacheGetResponse(response)
         except Exception as e:
+            _momento_logger.debug(f'Get failed for {key} with response: {e}')
             raise _cache_service_errors_converter.convert(e)
 
     def _asBytes(self, data, errorMessage):

src/momento/cache_operation_responses.py

@@ -1,6 +1,7 @@
 from enum import Enum
 from momento_wire_types import cacheclient_pb2 as cache_client_types
 from . import _cache_service_errors_converter as error_converter
+from . import _momento_logger
 
 
 class CacheResult(Enum):
@@ -12,6 +13,7 @@ class CacheSetResponse:
     def __init__(self, grpc_set_response, value):
         self._value = value
         if (grpc_set_response.result is not cache_client_types.Ok):
+            _momento_logger.debug(f'Set received unsupported ECacheResult {grpc_set_response.result}')
             raise error_converter.convert_ecache_result(
                 grpc_set_response.result, grpc_set_response.message)
 
@@ -28,6 +30,7 @@ def __init__(self, grpc_get_response):
 
         if (grpc_get_response.result is not cache_client_types.Hit
                 and grpc_get_response.result is not cache_client_types.Miss):
+            _momento_logger.debug(f'Get received unsupported ECacheResult: {grpc_get_response.result}')
             raise error_converter.convert_ecache_result(
                 grpc_get_response.result, grpc_get_response.message)
 

src/momento/momento.py

@@ -11,6 +11,7 @@
 from .cache_operation_responses import CreateCacheResponse
 from .cache_operation_responses import DeleteCacheResponse
 from .cache_operation_responses import ListCachesResponse
+from . import _momento_logger
 
 
 class Momento:
@@ -36,18 +37,22 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
 
     def create_cache(self, cache_name):
         try:
+            _momento_logger.debug(f'Creating cache with name: {cache_name}')
             request = CreateCacheRequest()
             request.cache_name = cache_name
             return CreateCacheResponse(self._client.CreateCache(request))
         except Exception as e:
+            _momento_logger.debug(f'Failed to create cache: {cache_name} with exception:{e}')
             raise _cache_service_errors_converter.convert(e) from None
 
     def delete_cache(self, cache_name):
         try:
+            _momento_logger.debug(f'Deleting cache with name: {cache_name}')
             request = DeleteCacheRequest()
             request.cache_name = cache_name
             return DeleteCacheResponse(self._client.DeleteCache(request))
         except Exception as e:
+            _momento_logger.debug(f'Failed to delete cache: {cache_name} with exception:{e}')
             raise _cache_service_errors_converter.convert(e) from None
 
     def get_cache(self, cache_name, ttl_seconds, create_if_absent=False):
@@ -59,6 +64,7 @@ def get_cache(self, cache_name, ttl_seconds, create_if_absent=False):
             if (not create_if_absent):
                 raise e
 
+        _momento_logger.debug(f'create_if_absent={create_if_absent}')
         self.create_cache(cache_name)
         return cache._connect()