import logging import boto3 from botocore.exceptions import BotoCoreError, ClientError from datetime import datetime import os import threading LOG_GROUP_NAME = '/aws/api_wrapper' LOG_STREAM_NAME = 'mconnect' # AWS error codes that mean the credentials will not start working on a retry, # so CloudWatch logging is switched off instead of failing on every log call. FATAL_ERROR_CODES = { 'AccessDeniedException', 'AuthFailure', 'ExpiredTokenException', 'InvalidClientTokenId', 'InvalidSignatureException', 'SignatureDoesNotMatch', 'UnrecognizedClientException', 'UnauthorizedOperation', } _logger = None _logger_lock = threading.Lock() class CloudWatchLogHandler(logging.Handler): _lock = threading.Lock() def __init__(self, log_group_name, log_stream_name): super().__init__() self.log_group_name = log_group_name self.log_stream_name = log_stream_name self.max_batch_size = 256000 # Max size for CloudWatch log event self.sequence_token = None self.enabled = True self.cloudwatch_logs = boto3.client( 'logs', aws_access_key_id=os.environ.get('CLOUDWATCH_ACCESS_KEY'), aws_secret_access_key=os.environ.get('CLOUDWATCH_SECRET_KEY'), region_name='ap-south-1' ) self._initialize_log_stream() def _initialize_log_stream(self): # Ensure the log group exists try: self.cloudwatch_logs.create_log_group(logGroupName=self.log_group_name) except self.cloudwatch_logs.exceptions.ResourceAlreadyExistsException: pass except (ClientError, BotoCoreError) as ex: self._disable(ex, 'create log group') return # Ensure the log stream exists try: if not self._log_stream_exists(): self.cloudwatch_logs.create_log_stream( logGroupName=self.log_group_name, logStreamName=self.log_stream_name ) except self.cloudwatch_logs.exceptions.ResourceAlreadyExistsException: pass except (ClientError, BotoCoreError) as ex: self._disable(ex, 'create log stream') def _log_stream_exists(self): response = self.cloudwatch_logs.describe_log_streams( logGroupName=self.log_group_name, logStreamNamePrefix=self.log_stream_name ) for stream in response.get('logStreams', []): if stream['logStreamName'] == self.log_stream_name: self.sequence_token = stream.get('uploadSequenceToken') return True return False def _disable(self, exception, action): """Stop using CloudWatch so the application keeps running on stdout logs.""" self.enabled = False print(f"CloudWatch logging disabled, could not {action}: {exception}") def emit(self, record): if not self.enabled: return log_message = self.format(record) timestamp = int(datetime.now().timestamp() * 1000) # Ensure thread safety when sending logs to CloudWatch with self._lock: try: kwargs = { 'logGroupName': self.log_group_name, 'logStreamName': self.log_stream_name, 'logEvents': [{ 'timestamp': timestamp, 'message': log_message }] } if self.sequence_token: kwargs['sequenceToken'] = self.sequence_token response = self.cloudwatch_logs.put_log_events(**kwargs) self.sequence_token = response['nextSequenceToken'] except ClientError as ex: error_code = ex.response.get('Error', {}).get('Code') if error_code in FATAL_ERROR_CODES: self._disable(ex, 'send log event') else: self.sequence_token = None print(f"Error sending log to CloudWatch: {ex}") except Exception as ex: print(f"Error sending log to CloudWatch: {ex}") def get_logger(): global _logger if _logger is not None: return _logger with _logger_lock: if _logger is not None: return _logger logger = logging.getLogger('api_wrapper') logger.setLevel(logging.INFO) if not logger.handlers: try: cloudwatch_handler = CloudWatchLogHandler( log_group_name=LOG_GROUP_NAME, log_stream_name=LOG_STREAM_NAME ) cloudwatch_handler.setFormatter( logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') ) logger.addHandler(cloudwatch_handler) except Exception as ex: # Never let logging setup break the application. print(f"CloudWatch logging unavailable: {ex}") logger.addHandler(logging.NullHandler()) _logger = logger return _logger def print_log(message): print(message) logger = get_logger() logger.info(message)