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'),
)
