def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(GreengrassPublishEvent, self).__init__(start_time) self.event_id = 'greengrass-{}'.format(str(uuid4())) self.resource['name'] = kwargs.get('topic', 'N/A') self.resource['operation'] = 'publish' if kwargs.get('queueFullPolicy'): self.resource['metadata']['aws.greengrass.queueFullPolicy'] = ( kwargs.get('queueFullPolicy')) add_data_if_needed(self.resource['metadata'], 'aws.greengrass.payload', kwargs.get('payload')) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch). :param event: event dict from the entry point. :param context: the context dict from the entry point. """ super(SQSLambdaTrigger, self).__init__(start_time) record = event['Records'][0] self.event_id = record['messageId'] self.resource['name'] = record['eventSourceARN'].split(':')[-1] self.resource['operation'] = 'ReceiveMessage' self.resource['metadata'] = { 'MD5 Of Message Body': record['md5OfBody'], 'Sender ID': record['attributes']['SenderId'], 'Approximate Receive Count': record['attributes']['ApproximateReceiveCount'], 'Sent Timestamp': record['attributes']['SentTimestamp'], 'Approximate First Receive Timestamp': record['attributes']['ApproximateFirstReceiveTimestamp'], } add_data_if_needed(self.resource['metadata'], 'Message Body', str(record['body']))
def update_response(self, response): """ Adds response data to event. :param response: Response from botocore :return: None """ response_headers, response_body = response self.resource['metadata']['status'] = int(response_headers['status']) self.resource = update_http_headers(self.resource, response_headers) full_url = self.resource['metadata']['url'] if not is_payload_collection_blacklisted(full_url): add_data_if_needed(self.resource['metadata'], 'response_headers', dict(response_headers)) # Extract only json responses try: if response_body: add_data_if_needed(self.resource['metadata'], 'response_body', json.loads(response_body)) except (TypeError, ValueError): # Skip if it is not a JSON body pass # Detect errors based on status code if int(response_headers['status']) >= HTTP_ERR_CODE: self.set_error()
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(GoogleRPCEvent, self).__init__(start_time) request_data = args[0] _, endpoint, operation = getattr(instance, '_method').split('/') endpoint = endpoint.split('.')[-1] self.event_id = 'grpc-{}'.format(str(uuid4())) self.resource['operation'] = operation self.resource['name'] = endpoint add_data_if_needed( self.resource['metadata'], 'Request Data', str(request_data) ) if response is not None: self.update_response(response) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point """ super(ElasticLoadBalancerLambdaTrigger, self).__init__(start_time) self.event_id = 'elb-{}'.format(str(uuid4())) self.resource['name'] = event['headers']['host'] self.resource['operation'] = event['httpMethod'] epsagon_trace_id = event['headers'].get(EPSAGON_HEADER) self.resource['metadata'] = { 'http_trace_id': epsagon_trace_id, 'query_string_parameters': event['queryStringParameters'], 'target_group_arn': (event['requestContext']['elb']['targetGroupArn']), 'path': event['path'] } if epsagon_trace_id: self.resource['metadata']['http_trace_id'] = epsagon_trace_id add_data_if_needed(self.resource['metadata'], 'body', event['body']) add_data_if_needed(self.resource['metadata'], 'headers', event['headers'])
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(UrllibEvent, self).__init__(start_time) self.event_id = 'urllib-{}'.format(str(uuid4())) prepared_request, data = args self.resource['name'] = normalize_http_url(prepared_request.full_url) self.resource['operation'] = prepared_request.get_method() self.resource['metadata']['url'] = prepared_request.full_url if not is_payload_collection_blacklisted(prepared_request.full_url): add_data_if_needed(self.resource['metadata'], 'request_headers', dict(prepared_request.headers)) add_data_if_needed(self.resource['metadata'], 'request_body', data) if response is not None: self.update_response(response) if exception is not None: self.set_exception(exception, traceback.format_exc())
def update_response(self, response): """ Adds response data to event. :param response: Response from botocore :return: None """ self.resource['metadata']['status_code'] = response.status headers = dict(response.getheaders()) self.resource = update_http_headers(self.resource, headers) self.resource['metadata']['response_body'] = None full_url = self.resource['metadata']['url'] if (not is_payload_collection_blacklisted(full_url) and not trace_factory.metadata_only): add_data_if_needed(self.resource['metadata'], 'response_headers', headers) if not SKIP_HTTP_CLIENT_RESPONSE: response_body = getattr(response, 'peek', None) if isinstance(response_body, bytes): try: response_body = response_body.decode('utf-8') except UnicodeDecodeError: response_body = str(response_body) add_data_if_needed(self.resource['metadata'], 'response_body', response_body) # Detect errors based on status code if response.status >= HTTP_ERR_CODE: self.set_error()
def update_response(self, response): """ Adds response data to event. :param response: Response from botocore :return: None """ self.resource['metadata']['status_code'] = response.status headers = dict(response.getheaders()) self.resource = update_http_headers( self.resource, headers ) self.resource['metadata']['response_body'] = None full_url = self.resource['metadata']['url'] if not is_payload_collection_blacklisted(full_url): add_data_if_needed( self.resource['metadata'], 'response_headers', headers ) # Detect errors based on status code if response.status >= HTTP_ERR_CODE: self.set_error()
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(RequestsEvent, self).__init__(start_time) self.event_id = 'requests-{}'.format(str(uuid4())) prepared_request = args[0] self.resource['name'] = normalize_http_url(prepared_request.url) self.resource['operation'] = prepared_request.method self.resource['metadata']['url'] = prepared_request.url add_data_if_needed(self.resource['metadata'], 'request_headers', dict(prepared_request.headers)) add_data_if_needed(self.resource['metadata'], 'request_body', prepared_request.body) if response is not None: self.update_response(response) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point """ super(SNSLambdaTrigger, self).__init__(start_time) self.event_id = str(event['Records'][0]['Sns']['MessageId']) self.resource['name'] = \ event['Records'][0]['EventSubscriptionArn'].split(':')[-2] self.resource['operation'] = str(event['Records'][0]['Sns']['Type']) self.resource['metadata'] = { 'Notification Subject': str(event['Records'][0]['Sns']['Subject']) } message = str(event['Records'][0]['Sns']['Message']) add_data_if_needed( self.resource['metadata'], 'Notification Message', message ) print_debug('Initialized SNS Lambda trigger')
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point """ super(NoProxyAPIGatewayLambdaTrigger, self).__init__(start_time) self.event_id = event['context']['request-id'] self.resource['name'] = event['params']['header'].get( 'Host', event['context']['api-id'] ) self.resource['operation'] = event['context']['http-method'] self.resource['metadata'] = { 'stage': event['context']['stage'], 'query_string_parameters': event['params']['querystring'], 'path_parameters': event['params']['path'], 'path': event['context']['resource-path'], } add_data_if_needed( self.resource['metadata'], 'body', event['body-json'] ) add_data_if_needed( self.resource['metadata'], 'headers', event['params']['header'] )
def update_response(self, future): """ Adds response data to event. :param future: Future response object :return: None """ response = future.result() self.resource['metadata']['status_code'] = response.code self.resource = update_http_headers(self.resource, dict(response.headers)) full_url = self.resource['metadata']['url'] if not is_payload_collection_blacklisted(full_url): add_data_if_needed(self.resource['metadata'], 'response_headers', dict(response.headers)) body = response.body if isinstance(body, bytes): try: body = body.decode('utf-8') except UnicodeDecodeError: body = str(body) if body: add_data_if_needed(self.resource['metadata'], 'response_body', body) # Detect errors based on status code if response.code >= HTTP_ERR_CODE: self.set_error()
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(Urllib3Event, self).__init__(start_time) self.event_id = 'urllib3-{}'.format(str(uuid4())) method, url = args body = kwargs.get('body') headers = kwargs.get('headers') if headers: # Make sure trace ID is present in case headers will be removed. epsagon_trace_id = headers.get('epsagon-trace-id') if epsagon_trace_id: self.resource['metadata']['http_trace_id'] = epsagon_trace_id parsed_url = urlparse(url) # Omitting ports (`:80'/':443') for the host URL. host_url = parsed_url.netloc.split(':')[0] full_url = urlunparse(( parsed_url.scheme, host_url, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment, )) self.resource['name'] = normalize_http_url(url) self.resource['operation'] = method self.resource['metadata']['url'] = full_url if not is_payload_collection_blacklisted(full_url): add_data_if_needed( self.resource['metadata'], 'request_headers', dict(headers) ) add_data_if_needed( self.resource['metadata'], 'request_body', body ) if response is not None: self.update_response(response) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point """ super(ProxyAPIGatewayLambdaTrigger, self).__init__(start_time) default_request_context = { 'requestId': str(uuid4()), 'apiId': 'N/A', 'stage': event.get('environment', 'N/A') } request_context = event.get('requestContext', default_request_context) self.event_id = request_context['requestId'] self.resource['name'] = event['headers'].get( 'Host', request_context.get('apiId') ) self.resource['operation'] = event.get( 'httpMethod', request_context.get('http', {}).get('method', 'GET') ) query_params = event.get( 'queryStringParameters', event.get('queryParams', 'N/A') ) path_params = event.get( 'pathParameters', event.get('pathParams', 'N/A') ) self.resource['metadata'] = { 'stage': request_context.get('stage', 'N/A'), 'query_string_parameters': query_params, 'path_parameters': path_params, 'path': event.get( 'resource', request_context.get('http', {}).get('path', 'N/A') ), } if 'body' in event: add_data_if_needed( self.resource['metadata'], 'body', event['body'] ) add_data_if_needed( self.resource['metadata'], 'headers', event['headers'] )
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(KafkaEvent, self).__init__(start_time) self.event_id = 'kafka-{}'.format(str(uuid4())) topic = args[0] headers = dict(kwargs['headers']) servers = instance.config['bootstrap_servers'] if servers and isinstance(servers, list): # Take the first server if it is a list servers = servers[0] self.resource['name'] = topic self.resource['operation'] = 'send' self.resource['metadata'] = { 'messaging.system': 'kafka', 'messaging.destination': topic, 'messaging.url': servers, 'messaging.message_payload_size_bytes': (len(str(kwargs.get('value', '')))), } if instance.config.get('client_id'): self.resource['metadata']['messaging.kafka.client_id'] = ( instance.config['client_id']) if headers.get(EPSAGON_HEADER): self.resource['metadata'][EPSAGON_HEADER] = ( headers[EPSAGON_HEADER]) if kwargs['key']: self.resource['metadata']['messaging.kafka.message_key'] = ( kwargs['key']) add_data_if_needed(self.resource['metadata'], 'messaging.headers', headers) add_data_if_needed(self.resource['metadata'], 'messaging.message', kwargs['value']) if getattr(response, 'value', None) is not None: self.update_response(response.value) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(TornadoAsyncHTTPClientEvent, self).__init__(start_time) self.event_id = 'tornado-client-{}'.format(str(uuid4())) request = args[0] headers = dict(request.headers) if headers: # Make sure trace ID is present in case headers will be removed. epsagon_trace_id = headers.get(EPSAGON_HEADER_TITLE) if epsagon_trace_id: self.resource['metadata']['http_trace_id'] = epsagon_trace_id parsed_url = urlparse(request.url) host_url = parsed_url.netloc.split(':')[0] full_url = urlunparse(( parsed_url.scheme, host_url, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment, )) self.resource['name'] = normalize_http_url(request.url) self.resource['operation'] = request.method self.resource['metadata']['url'] = request.url if not is_payload_collection_blacklisted(full_url): add_data_if_needed(self.resource['metadata'], 'request_headers', headers) body = request.body if isinstance(body, bytes): body = body.decode('utf-8') if body: add_data_if_needed(self.resource['metadata'], 'request_body', body) if response is not None: callback = functools.partial(self.update_response) response.add_done_callback(callback) if exception is not None: self.set_exception(exception, traceback.format_exc())
def update_response(self, response): """ Adds response data to event. :param response: Response from botocore :return: None """ add_data_if_needed( self.resource['metadata'], 'Response Data', str(response) )
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch). :param event: event dict from the entry point. :param context: the context dict from the entry point. """ super(SQSLambdaTrigger, self).__init__(start_time) record = event['Records'][0] self.event_id = record['messageId'] self.resource['name'] = record['eventSourceARN'].split(':')[-1] self.resource['operation'] = 'ReceiveMessage' self.resource['metadata'] = { 'MD5 Of Message Body': record['md5OfBody'], 'Sender ID': record['attributes']['SenderId'], 'Approximate Receive Count': record['attributes'][ 'ApproximateReceiveCount' ], 'Sent Timestamp': record['attributes']['SentTimestamp'], 'Approximate First Receive Timestamp': record['attributes'][ 'ApproximateFirstReceiveTimestamp' ], } sqs_message_body = record['body'] self.resource['metadata']['Number Of Messages'] = len(event['Records']) add_data_if_needed( self.resource['metadata'], 'Message Body', str(sqs_message_body) ) message_body = parse_json(sqs_message_body) if not message_body: return message_body_input = message_body.get('input') if not message_body_input: return if isinstance(message_body_input, dict): steps_dict = message_body_input.get('Epsagon') if not steps_dict: return self.resource['metadata'] = {'steps_dict': steps_dict}
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point """ super(JSONLambdaTrigger, self).__init__(start_time) self.event_id = 'trigger-{}'.format(str(uuid4())) self.resource['name'] = 'trigger-{}'.format(context.function_name) self.resource['operation'] = self.RESOURCE_TYPE self.resource['metadata'] = {} add_data_if_needed(self.resource['metadata'], 'data', event)
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(PyMongoEvent, self).__init__(start_time) documents = args[0] self.event_id = 'mongo-{}'.format(str(uuid4())) self.resource['name'] = instance.full_name self.resource['operation'] = \ 'insert_many' if isinstance(documents, list) else 'insert_one' address = list(getattr( instance.database.client, '_topology_settings' ).seeds)[0] if self.resource['operation'] == 'insert_one': documents = [documents] self.resource['metadata'] = { 'DB URL': ':'.join([str(x) for x in address]), 'DB Name': str(instance.database.name), 'Collection Name': str(instance.name), } add_data_if_needed(self.resource['metadata'], 'Items', documents) if response is not None: self.update_response(response) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(Httplib2Event, self).__init__(start_time) self.event_id = 'httplib2-{}'.format(str(uuid4())) # Params can be set via args or kwargs. url, method, body, headers = Httplib2Event.unroller(*args, **kwargs) url_obj = urlparse(url) self.resource['name'] = url_obj.hostname self.resource['operation'] = method self.resource['metadata']['url'] = url if not is_payload_collection_blacklisted(url): if headers: add_data_if_needed(self.resource['metadata'], 'request_headers', headers) try: if body: add_data_if_needed(self.resource['metadata'], 'request_body', json.loads(body)) except (TypeError, ValueError): # Skip if it is not a JSON body pass if response is not None: self.update_response(response) if exception is not None: self.set_exception(exception, traceback.format_exc())
def update_response(self, response, is_stream): """ Adds response data to event. :param response: the Response object :return: None """ self.resource['metadata']['status_code'] = response.status_code self.resource = update_http_headers(self.resource, response.headers) add_data_if_needed(self.resource['metadata'], 'response_headers', dict(response.headers)) if (not trace_factory.metadata_only and not SKIP_HTTP_CLIENT_RESPONSE): add_data_if_needed( self.resource['metadata'], 'response_body', type(self)._get_response_body(response, is_stream)) # Detect errors based on status code if response.status_code >= HTTP_ERR_CODE: self.set_error()
def __init__(self, start_time, event, context, runner): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point :param runner: SCF runner event """ super(TimerTrigger, self).__init__(start_time) self.event_id = 'timer-{}'.format(str(uuid4())) self.resource['name'] = event['TriggerName'] self.resource['operation'] = 'Timer' self.resource['metadata'] = { 'tencent.timer.timestamp': event['Time'], } add_data_if_needed(self.resource['metadata'], 'tencent.timer.message', event['Message'])
def update_response(self, response): """ Adds response data to event. :param response: Response from botocore :return: None """ self.resource['metadata']['status_code'] = response.status_code self.resource = update_http_headers( self.resource, response.headers ) add_data_if_needed( self.resource['metadata'], 'response_headers', dict(response.headers) ) self.resource['metadata']['response_body'] = None response_body = None try: response_body = json.loads(response.content) except ValueError: response_body = response.content if isinstance(response_body, bytes): try: response_body = response_body.decode('utf-8') except UnicodeDecodeError: response_body = str(response_body) add_data_if_needed( self.resource['metadata'], 'response_body', response_body ) # Detect errors based on status code if response.status_code >= HTTP_ERR_CODE: self.set_error()
def __init__(self, start_time, event, context): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point """ super(DynamoDBLambdaTrigger, self).__init__(start_time) self.deserializer = TypeDeserializer() if TypeDeserializer else None record = event['Records'][0] self.event_id = record['eventID'] self.resource['name'] = record['eventSourceARN'].split('/')[-3] self.resource['operation'] = record['eventName'] if record['eventName'] == 'REMOVE': deserialized_item = self._deserialize_item( record['dynamodb']['Keys'] ) elif record['eventName'] == 'MODIFY': deserialized_item = self._deserialize_item( record['dynamodb']['Keys'] ) else: item = record['dynamodb']['NewImage'] deserialized_item = self._deserialize_item(item) add_data_if_needed(self.resource['metadata'], 'New Image', item) self.resource['metadata'] = { 'region': record['awsRegion'], 'sequence_number': record['dynamodb']['SequenceNumber'], } if deserialized_item is not None: self.resource['metadata']['item_hash'] = hashlib.md5( json.dumps(deserialized_item, sort_keys=True).encode('utf-8') ).hexdigest()
def __init__(self, start_time, event, context, runner): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point :param runner: SCF runner event """ super(KafkaTrigger, self).__init__(start_time) record = event['Records'][0]['Ckafka'] self.event_id = record['msgKey'] self.resource['name'] = record['topic'] self.resource['operation'] = 'consume' self.resource['metadata'] = { 'messaging.message.partition': record['partition'], 'messaging.message.offset': record['offset'], 'messaging.message.key': record['msgKey'], } add_data_if_needed(self.resource['metadata'], 'messaging.message.body', record['msgBody'])
def __init__(self, wrapped, instance, args, kwargs, start_time, response, exception): """ Initialize. :param wrapped: wrapt's wrapped :param instance: wrapt's instance :param args: wrapt's args :param kwargs: wrapt's kwargs :param start_time: Start timestamp (epoch) :param response: response data :param exception: Exception (if happened) """ super(RequestsEvent, self).__init__(start_time) self.event_id = 'requests-{}'.format(str(uuid4())) prepared_request = args[0] self.resource['name'] = normalize_http_url(prepared_request.url) self.resource['operation'] = prepared_request.method self.resource['metadata']['url'] = prepared_request.url add_data_if_needed(self.resource['metadata'], 'request_headers', dict(prepared_request.headers)) epsagon_trace_id = prepared_request.headers.get(EPSAGON_HEADER) # Make sure trace ID is present in case headers will be removed. if epsagon_trace_id: self.resource['metadata']['http_trace_id'] = epsagon_trace_id add_data_if_needed(self.resource['metadata'], 'request_body', prepared_request.body) if response is not None: self.update_response(response, kwargs.get('stream', False)) if exception is not None: self.set_exception(exception, traceback.format_exc())
def __init__(self, start_time, event, context, runner): """ Initialize. :param start_time: event's start time (epoch) :param event: event dict from the entry point :param context: the context dict from the entry point :param runner: SCF runner event """ super(CMQTrigger, self).__init__(start_time) record = event['Records'][0]['CMQ'] self.event_id = record['msgId'] self.resource['name'] = record['topicName'] self.resource['operation'] = 'consume' self.resource['metadata'] = { 'tencent.cmq.message.id': record['msgId'], 'tencent.cmq.message.tags': record['msgTag'], 'tencent.cmq.request_id': record['requestId'], 'tencent.cmq.subscription_name': record['subscriptionName'], } add_data_if_needed(self.resource['metadata'], 'tencent.cmq.message.body', record['msgBody'])
def update_response(self, response): """ Adds response data to event. :param response: Response from botocore :return: None """ self.resource['metadata']['status_code'] = response.status_code self.resource = update_http_headers(self.resource, response.headers) add_data_if_needed(self.resource['metadata'], 'response_headers', dict(response.headers)) # Extract only json responses self.resource['metadata']['response_body'] = None try: add_data_if_needed(self.resource['metadata'], 'response_body', response.json()) except ValueError: pass # Detect errors based on status code if response.status_code >= HTTP_ERR_CODE: self.set_error()
def __init__(self, start_time, event, _context): """ Initialize Trigger :param start_time: event's start time (epoch unix) :param event: event dict from entry point :param context: context dict from entry point """ super(CognitoLambdaTrigger, self).__init__(start_time) self.event_id = 'cognito-{uid}'.format(uid=str(uuid4())) self.resource['name'] = event.get('userPoolId') self.resource['operation'] = event.get('triggerSource') self.resource['metadata'] = { 'region': event.get('region'), 'username': event.get('userName'), 'client_id': event.get('callerContext', {}).get('clientId'), 'user_pool_id': event.get('userPoolId'), 'trigger_source': event.get('triggerSource'), 'version': event.get('version') } add_data_if_needed( self.resource['metadata'], 'attributes', event.get('request', {}).get('userAttributes') ) add_data_if_needed( self.resource['metadata'], 'session', event.get('request', {}).get('session') ) add_data_if_needed( self.resource['metadata'], 'callercontext', event.get('callerContext') ) add_data_if_needed( self.resource['metadata'], 'response', event.get('response'), )