def handle_message(self, message, bound_handlers) -> MessageHandlingResult:
"""
Handle a message.
"""
with self.opaque.initialize(self.sqs_message_context, message):
handler = None
with elapsed_time(self.opaque):
try:
self.validate_message(message)
handler = self.find_handler(message, bound_handlers)
instance = MessageHandlingResult.invoke(
handler=self.wrap_handler(handler),
message=message,
)
except Exception as error:
instance = MessageHandlingResult.from_error(
message=message,
error=error,
)
instance.elapsed_time = self.opaque["elapsed_time"]
instance.log(
logger=self.choose_logger(handler),
opaque=self.opaque,
)
instance.resolve(message)
return instance
def handle_message(self, message, bound_handlers) -> MessageHandlingResult:
"""
Handle a message.
"""
with self.opaque.initialize(self.sqs_message_context, message):
handler = None
with elapsed_time(self.opaque):
try:
self.validate_message(message)
handler = self.find_handler(message, bound_handlers)
instance = MessageHandlingResult.invoke(
handler=self.wrap_handler(handler),
message=message,
)
except Exception as error:
instance = MessageHandlingResult.from_error(
message=message,
error=error,
)
instance.elapsed_time = self.opaque["elapsed_time"]
instance.log(
logger=self.choose_logger(handler),
opaque=self.opaque,
)
instance.resolve(message)
return instance
def test_error_reporting_only_sends_on_relevant_result_type(self, result_type, error_reported):
result = MessageHandlingResult(result=result_type, media_type="media", exc_info=(1, 2, 3))
sentry_config = SentryConfigPubsub(enabled=True)
with patch.object(result, "_report_error") as mock_report:
result.error_reporting(sentry_config, self.graph.opaque)
if error_reported:
mock_report.assert_called_once_with(self.graph.opaque, dict(), None)
else:
mock_report.assert_not_called()
def handle_message(self, message, bound_handlers) -> MessageHandlingResult:
"""
Handle a message.
"""
with self.opaque.initialize(self.sqs_message_context, message):
handler = None
start_handle_time = time()
with elapsed_time(self.opaque):
try:
self.validate_message(message)
handler = self.find_handler(message, bound_handlers)
instance = MessageHandlingResult.invoke(
handler=self.wrap_handler(handler),
message=message,
)
except Exception as error:
instance = MessageHandlingResult.from_error(
message=message,
error=error,
)
instance.elapsed_time = self.opaque["elapsed_time"]
published_time = self.opaque.get(PUBLISHED_KEY)
if published_time:
instance.handle_start_time = start_handle_time - float(
published_time)
instance.log(
logger=self.choose_logger(handler),
opaque=self.opaque,
)
instance.error_reporting(
sentry_config=self.sentry_config,
opaque=self.opaque,
)
instance.resolve(message)
return instance
def test_log_merge_keys(self):
def handler(message):
return True
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
result.extra = dict(
media_type="foo.created",
foo="bar",
)
self.graph.opaque["foo"] = "baz"
# This doesn't error
result.log(
self.graph.logger,
self.graph.opaque,
)
def test_skipped_falsey(self):
def handler(message):
return False
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.SKIPPED,
),
)
# ack
self.graph.sqs_consumer.sqs_client.delete_message.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
)
def test_ttl_expired(self):
def handler(message):
raise TTLExpired("too many attempts")
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.EXPIRED,
),
)
# ack
self.graph.sqs_consumer.sqs_client.delete_message.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
)
def test_ignored_exception(self):
def handler(message):
raise IgnoreMessage("ignorance is bliss")
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.IGNORED,
),
)
# ack
self.graph.sqs_consumer.sqs_client.delete_message.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
)
def test_skipped_falsey(self):
def handler(message):
return False
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.SKIPPED,
),
)
# ack
self.graph.sqs_consumer.sqs_client.delete_message.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
)
def test_ttl_expired(self):
def handler(message):
raise TTLExpired("too many attempts")
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.EXPIRED,
),
)
# ack
self.graph.sqs_consumer.sqs_client.delete_message.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
)
def test_ignored_exception(self):
def handler(message):
raise IgnoreMessage("ignorance is bliss")
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.IGNORED,
),
)
# ack
self.graph.sqs_consumer.sqs_client.delete_message.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
)
def test_failed_exception(self):
def handler(message):
raise Exception("FAIL")
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.FAILED,
),
)
# nack with default retry visibility timeout
self.graph.sqs_consumer.sqs_client.change_message_visibility.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
VisibilityTimeout=5,
)
def test_failed_exception(self):
def handler(message):
raise Exception("FAIL")
result = MessageHandlingResult.invoke(
handler=handler,
message=self.message,
).resolve(self.message)
assert_that(
result,
has_properties(
media_type="application/vnd.microcosm.derived",
result=MessageHandlingResultType.FAILED,
),
)
# nack with default retry visibility timeout
self.graph.sqs_consumer.sqs_client.change_message_visibility.assert_called_with(
QueueUrl="queue",
ReceiptHandle=RECEIPT_HANDLE,
VisibilityTimeout=5,
)
