def handle_entry(self, entry):
self.last_used = time()
history_item = dict(start_time=self.last_used, entry=entry)
self.history.append(history_item)
if entry["source"] == "shell":
if self.awaiting_input:
self.input_queue.put(entry["input"])
else:
self.task_queue.put(entry)
else:
if not TESTING and self.awaiting_input:
self.start_process()
self.task_queue.put(entry)
result = self._await_result()
if result["error"] and result["error"]["sentry_event"]:
sentry_sdk.capture_event(result["error"]["sentry_event"])
self.awaiting_input = result["awaiting_input"]
history_item.update(
end_time=time(),
elapsed=time() - history_item["start_time"],
result=select_keys(result, "passed output awaiting_input"),
)
return result
def _getMetricValue(self, metric: QAMetric, date: str, snapshot: int, isProjected: bool):
metric_path = metric.projection_path if isProjected else metric.actual_path
if not metric_path:
return None
data_at_date = self._date_to_data.get(date)
if not data_at_date:
capture_event(
{
"message": "{self.state} missing data for a given date",
"extra": {
"state": self.state,
"snapshot": snapshot,
"metric": metric.name,
"missing_date": date,
},
}
)
return None
data = data_at_date.get(snapshot)
if not data:
# This might be because the snapshot doesn't have data to compare it to (like the dates might not overlap)
return None
current_data = data
for path_segment in metric_path:
current_data = current_data.get(path_segment)
if current_data is None:
# this would be for the actuals we wouldn't have future values
return None
if isinstance(current_data, float):
current_data = round(current_data, 4)
return current_data
def update_info(self):
res = self.calculation_manager.get_results()
for el in res.errors:
if el[0]:
QListWidgetItem(el[0], self.logs)
ExceptionListItem(el[1], self.logs)
if (state_store.report_errors and parsed_version.is_devrelease
and not isinstance(el[1][0], SegmentationLimitException)
and isinstance(el[1][1], tuple)):
with sentry_sdk.push_scope() as scope:
scope.set_tag("auto_report", "true")
sentry_sdk.capture_event(el[1][1][0])
self.whole_progress.setValue(res.global_counter)
working_search = True
for uuid, progress in res.jobs_status.items():
calculation = self.calculation_manager.calculation_dict[uuid]
total = len(calculation.file_list)
if uuid in self.progress_item_dict:
item = self.progress_item_dict[uuid]
item.update_count(progress)
else:
item = CalculationProcessItem(calculation, self.task_count,
progress)
self.task_count += 1
self.task_que.appendRow(item)
self.progress_item_dict[uuid] = item
if working_search and progress != total:
self.part_progress.setMaximum(total)
self.part_progress.setValue(progress)
working_search = False
if not self.calculation_manager.has_work:
self.part_progress.setValue(self.part_progress.maximum())
self.preview_timer.stop()
logging.info("Progress stop")
def update_info(self):
res = self.calculation_manager.get_results()
for el in res.errors:
if el[0]:
QListWidgetItem(el[0], self.logs)
ExceptionListItem(el[1], self.logs)
if (state_store.report_errors and parsed_version.is_devrelease
and not isinstance(el[1][0], SegmentationLimitException)
and isinstance(el[1][1], tuple)):
with sentry_sdk.push_scope() as scope:
scope.set_tag("auto_report", "true")
sentry_sdk.capture_event(el[1][1][0])
self.whole_progress.setValue(res.global_counter)
working_search = True
for i, (progress, total) in enumerate(res.jobs_status):
if working_search and progress != total:
self.part_progress.setMaximum(total)
self.part_progress.setValue(progress)
working_search = False
if i < self.task_que.count():
item = self.task_que.item(i)
item.setText("Task {} ({}/{})".format(i, progress, total))
else:
self.task_que.addItem("Task {} ({}/{})".format(
i, progress, total))
if not self.calculation_manager.has_work:
print(
"[ProgressView.update_info]",
self.calculation_manager.has_work,
self.calculation_manager.batch_manager.has_work,
self.calculation_manager.writer.writing_finished(),
)
self.part_progress.setValue(self.part_progress.maximum())
self.preview_timer.stop()
logging.info("Progress stop")
async def error_middleware(request, handler):
request['start_time'] = get_request_start(request)
try:
r = await handler(request)
except HTTPException as e:
should_warn_ = request.app.get('middleware_should_warn') or should_warn
if should_warn_(e):
await log_warning(request, e)
raise
except Exception as exc:
message, event = await event_extra(request,
exception_extra=exc_extra(exc))
# make sure these errors appear independently
event['fingerprint'] += (repr(exc), )
message += f', {exc!r}'
logger.exception(message, extra=event)
exc_data, hint = event_from_exception(exc_info_from_error(exc))
event.update(exc_data)
event.update(level='error', message=message)
capture_event(event, hint)
raise HTTPInternalServerError() from exc
else:
# TODO cope with case that r is not a response
should_warn_ = request.app.get('middleware_should_warn') or should_warn
if should_warn_(r):
await log_warning(request, r)
return r
def test_capture_event_with_scope_kwargs(sentry_init, capture_events):
sentry_init(debug=True)
events = capture_events()
capture_event({}, level="info", extras={"foo": "bar"})
(event,) = events
assert event["level"] == "info"
assert event["extra"]["foo"] == "bar"
def raising(self, info):
""" Log an exception and send the info to sentry """
exc_info = sys.exc_info()
res = SiteErrorLog.raising(self, info)
send_anyway = os.environ.get(SEND_ANYWAY_ENV_VAR, '')
if getConfiguration().debug_mode and not send_anyway:
# We are in debug mode, do not send tb to Sentry
logger.info('Zope is in debug mode. Not sending error to sentry')
return res
dsn = self.getsentry_dsn
dsn = dsn and dsn or os.environ.get(DSN_ENV_VAR, '')
if not dsn:
logger.warning('Missing DSN. Unable to send errors to sentry')
return res
if res is not None:
client = get_or_create_client(dsn)
event, hint = event_from_exception(exc_info,
client_options=client.options)
hub = Hub.current
hub.start_session()
with sentry_sdk.push_scope() as scope:
request = getattr(self, 'REQUEST', None)
if not request:
request = getRequest()
_prepare_scope_and_event(request, scope, event)
sentry_sdk.capture_event(event, hint, scope)
hub.end_session()
return res
def test_sentry_variables_clip(monkeypatch):
letters = "abcdefghijklmnoprst"
for letter in letters:
locals()[letter] = 1
try:
raise ValueError("eeee")
except ValueError as ee:
event, hint = sentry_sdk.utils.event_from_exception(ee)
vars_dict = event["exception"]["values"][0]["stacktrace"]["frames"][0][
"vars"]
for letter in letters:
assert letter in vars_dict
cliped = serialize(event)
assert len(cliped["exception"]["values"][0]["stacktrace"]["frames"][0]
["vars"]) == 10
monkeypatch.setattr(sentry_sdk.serializer, "MAX_DATABAG_BREADTH", 100)
cliped = serialize(event)
assert len(cliped["exception"]["values"][0]["stacktrace"]["frames"][0]
["vars"]) == len(vars_dict)
assert len(cliped["exception"]["values"][0]["stacktrace"]["frames"][0]
["vars"]) > 10
client = Client("https://[email protected]/77")
Hub.current.bind_client(client)
sentry_sdk.capture_event(event, hint=hint)
def handle_error(self, exception_type, value, traceback):
exc_info = (exception_type, value, traceback)
with sentry_sdk.push_scope() as scope:
event, hint = event_from_exception(exc_info)
scope.set_extra("remotecv-version", __version__)
sentry_sdk.capture_event(event, hint=hint)
def sentry_emit_commodity_not_found(commodity_code, nomenclature_sid):
sentry_sdk.capture_event(
{
"message": "Commodity object not found",
"level": "warning",
"extra": {
"commodity_code": commodity_code,
"nomenclature_sid": nomenclature_sid,
},
}
)
async def log_warning(request: Request, response: Optional[Response]):
message, event = await event_extra(request, response)
logger.warning(message, extra=event)
event['message'] = message
if isinstance(response, Exception):
exc_data, hint = event_from_exception(exc_info_from_error(response))
event.update(exc_data)
capture_event(event, hint)
else:
capture_event(event)
def send_message(args):
''' Mandatory args: message '''
margs = copy.copy(args)
[ margs.pop(i) for i in ['verbose',] ]
with sentry_sdk.push_scope() as local_scope:
if margs.get('level', False):
local_scope.level = margs.pop('level')
if margs.get('request', False):
local_scope.request = margs.pop('request')
for k,v in margs.pop('extra', {}).items():
local_scope.set_extra(k, v)
for k,v in margs.pop('tags', {}).items():
local_scope.set_tag(k, v)
if margs.get('email', False):
email_address= margs.pop('email')
local_scope.user = {
"email": email_address,
}
eventid = sentry_sdk.capture_event(margs)
if args.get('verbose', True):
if eventid:
print('Sent Event ID: {}'.format(eventid))
else:
print('Error sending Event "{}" !'.format(margs.message), file=sys.stderr)
return eventid
def inner(*args, **kwargs):
event_id = sentry_sdk.capture_event(*args, **kwargs)
Hub.current.client.flush()
with push_scope():
return wait_for_ingest_consumer(lambda: eventstore.get_event_by_id(
settings.SENTRY_PROJECT, event_id))
def _log(self, event_dict: dict) -> str:
"""Send an event to Sentry and return sentry event id.
:param event_dict: structlog event_dict
"""
event, hint = self._get_event_and_hint(event_dict)
return capture_event(event, hint=hint)
def handle_error(self, context, handler, exception):
req = handler.request
exc_info = exc_info_from_error(exception)
with sentry_sdk.push_scope() as scope:
event, hint = event_from_exception(exc_info)
event["request"] = {
"url": req.full_url(),
"method": req.method,
"data": req.arguments,
"query_string": req.query,
"headers": req.headers,
"body": req.body,
}
scope.set_extra('thumbor-version', __version__)
sentry_sdk.capture_event(event, hint=hint)
def test_envelope_headers(sentry_init, capture_envelopes, monkeypatch,
tracestate_enabled):
monkeypatch.setattr(
sentry_sdk.client,
"format_timestamp",
lambda x: "2012-11-21T12:31:12.415908Z",
)
monkeypatch.setattr(
sentry_sdk.client,
"has_tracestate_enabled",
mock.Mock(return_value=tracestate_enabled),
)
sentry_init(
dsn=
"https://[email protected]/12312012",
)
envelopes = capture_envelopes()
capture_event(generate_transaction_item())
assert len(envelopes) == 1
if tracestate_enabled:
assert envelopes[0].headers == {
"event_id": "15210411201320122115110420122013",
"sent_at": "2012-11-21T12:31:12.415908Z",
"trace": {
"trace_id": "12312012123120121231201212312012",
"environment": "dogpark",
"release": "off.leash.park",
"public_key": "dogsarebadatkeepingsecrets",
"user": {
"id": 12312013,
"segment": "bigs"
},
"transaction": "/interactions/other-dogs/new-dog",
},
}
else:
assert envelopes[0].headers == {
"event_id": "15210411201320122115110420122013",
"sent_at": "2012-11-21T12:31:12.415908Z",
}
def send_information(self):
"""
Function with construct final error message and send it using sentry.
"""
with sentry_sdk.push_scope() as scope:
text = self.desc.text() + "\n\nVersion: " + __version__ + "\n"
if len(self.additional_notes) > 0:
scope.set_extra("additional_notes", self.additional_notes)
if len(self.additional_info.toPlainText()) > 0:
scope.set_extra("user_information",
self.additional_info.toPlainText())
if len(self.contact_info.text()) > 0:
scope.set_extra("contact", self.contact_info.text())
event, hint = self.exception_tuple
event["message"] = text
if self.traceback_summary is not None:
scope.set_extra("traceback",
self.error_description.toPlainText())
event_id = sentry_sdk.capture_event(event, hint=hint)
if event_id is None:
event_id = sentry_sdk.hub.Hub.current.last_event_id()
if len(self.additional_info.toPlainText()) > 0:
contact_text = self.contact_info.text()
user_name = self.user_name.text()
data = {
"comments": self.additional_info.toPlainText(),
"event_id": event_id,
"email": contact_text if _email_regexp.match(contact_text) else
"*****@*****.**",
"name": user_name or getpass.getuser(),
}
r = requests.post(
url=_feedback_url,
data=data,
headers={
"Authorization":
"DSN https://[email protected]/1309302"
},
)
if r.status_code != 200:
data["email"] = "*****@*****.**"
data["name"] = getpass.getuser()
requests.post(
url=_feedback_url,
data=data,
headers={
"Authorization":
"DSN https://[email protected]/1309302"
},
)
# sentry_sdk.capture_event({"message": text, "level": "error", "exception": self.exception})
self.accept()
def handle_error(self, context, handler, exception): # pylint: disable=unused-argument
req = handler.request
exc_info = exc_info_from_error(exception)
with sentry_sdk.push_scope() as scope:
event, hint = event_from_exception(exc_info)
event["request"] = {
"url": req.full_url(),
"method": req.method,
"data": req.arguments,
"query_string": req.query,
"headers": req.headers,
"body": req.body,
}
scope.set_extra("thumbor-version", __version__)
scope.set_extra("thumbor-loader", self.config.LOADER)
scope.set_extra("thumbor-storage", self.config.STORAGE)
sentry_sdk.capture_event(event, hint=hint)
def test_sentry_report(monkeypatch):
message = "a" * 5000
happen = [False]
def check_event(event):
happen[0] = True
assert len(event["message"]) == 512
assert len(event["extra"]["lorem"]) == 512
try:
raise ValueError("eeee")
except ValueError as e:
event, hint = sentry_sdk.utils.event_from_exception(e)
event["message"] = message
client = Client("https://[email protected]/77")
Hub.current.bind_client(client)
monkeypatch.setattr(client.transport, "capture_event", check_event)
with sentry_sdk.push_scope() as scope:
scope.set_extra("lorem", message)
sentry_sdk.capture_event(event, hint=hint)
assert happen[0] is True
def _metric_diff(self, date, metric, value1, value2, metric_type) -> MetricDiff:
metric_diff = MetricDiff(
self.state,
self.county,
self.fips,
date,
metric.name,
metric_type,
self.snapshot1,
value1,
self.snapshot2,
value2,
metric.diff(value1, value2),
metric.threshold,
metric.threshold_diff_value(value1, value2),
)
capture_event(
{
"message": f"State has over threshold metrics",
"tags": {
"state": self.state,
"county": self.county,
"fips": self.fips,
"metric_date": date,
"metric": metric.name,
"metric_type": metric_type,
},
"extra": {
"snapshot1": self.snapshot1,
"value1": value1,
"snapshot2": self.snapshot2,
"value2": value2,
"metric_diff": metric.diff(value1, value2),
"metric_threshold": metric.threshold,
"metric_diff_value": metric.threshold_diff_value(value1, value2),
},
}
)
return metric_diff
def user_role(self):
# seen as public access if no auth header provided
if not self.auth_header:
event = self._get_event(
"no-auth", "Authorization failed: no auth header provided")
capture_event(event)
raise PermissionDenied()
if not self.is_valid:
event = self._get_event(
"invalid-auth",
"Authorization failed: invalid auth header provided")
capture_event(event)
raise PermissionDenied()
if self.has_admin_group:
return UserRole.ADMIN
elif self.has_office_hki_group:
return UserRole.OFFICE_HKI
elif self.has_office_group:
return UserRole.OFFICE
else:
return UserRole.PUBLIC
def test_exception_pass(monkeypatch):
def check_event(event):
assert len(
event["exception"]["values"][0]["stacktrace"]["frames"]) == 12
message_queue = multiprocessing.Queue()
p = multiprocessing.Process(target=executor_fun, args=(message_queue, ))
p.start()
p.join()
ex, event, _tr = message_queue.get()
assert isinstance(ex, ValueError)
assert isinstance(event, dict)
client = Client("https://[email protected]/77")
Hub.current.bind_client(client)
monkeypatch.setattr(client.transport, "capture_event", check_event)
event_id = sentry_sdk.capture_event(event)
assert event_id is not None
async def log(self,
request: Request,
*,
exc: Optional[Exception] = None,
response: Optional[Response] = None) -> None:
event_data = await request_log_extra(request, exc, response)
event_data['user'] = await self.user_info(request)
view_ref = event_data['transaction']
if exc:
level = 'error'
message = f'"{line_one(request)}", {exc!r}'
fingerprint = view_ref, request.method, repr(exc)
request_logger.exception(message, extra=event_data)
else:
assert response is not None
level = 'warning'
message = f'"{line_one(request)}", unexpected response: {response.status_code}'
request_logger.warning(message, extra=event_data)
fingerprint = view_ref, request.method, str(response.status_code)
if glove.settings.sentry_dsn:
hint = None
if exc:
exc_data, hint = event_from_exception(exc_info_from_error(exc))
event_data.update(exc_data)
event_data.update(message=message,
level=level,
logger='foxglove.request_errors',
fingerprint=fingerprint)
if not capture_event(event_data, hint):
logger.critical(
'sentry not configured correctly, not sending message: %s',
message,
extra={'event_data': event_data},
)
def capture_event(base_event):
if Sentry.init_sentry():
config = Configuration.get_solo()
if config.capture_event:
sentry_sdk.capture_event(base_event)
def send_event_to_sentry(*, event_dict: EventDict, level: SentryLevel,
tag_keys: SentryTagKeys) -> Optional[str]:
event, hint = _get_event_and_hint(event_dict=event_dict,
level=level,
tag_keys=tag_keys)
return capture_event(event, hint=hint)
def test_capture_event_works(sentry_init):
sentry_init(transport=_TestTransport())
pytest.raises(EventCaptured, lambda: capture_event({}))
pytest.raises(EventCaptured, lambda: capture_event({}))
def upload(self, path_to_core):
"""Uploads the event to sentry"""
# Validate input Path
if os.path.isfile(path_to_core) is not True:
error("Wrong path to coredump")
if self.all_threads:
gdb_output = self.execute_gdb(path_to_core, "thread apply all bt")
(
thread_list,
exit_signal,
stacktrace,
crashed_thread_id,
) = get_threads(gdb_output)
else:
gdb_output = self.execute_gdb(path_to_core, "bt")
stacktrace, exit_signal = get_stacktrace(gdb_output)
thread_list = None
crashed_thread_id = None
# gets the registers, the gdb-version and the message
stacktrace, gdb_version, message = self.get_registers(
path_to_core, stacktrace)
image_list = []
# Searches for images in the Eu-Unstrip Output
eu_unstrip_output = self.execute_elfutils(path_to_core)
for match in re.finditer(_image_re, eu_unstrip_output):
image = get_image(match)
if image is not None:
image_list.append(image)
# Get timestamp
timestamp = get_timestamp(path_to_core)
# Get signal Number from signal name
exit_signal_number = signal_name_to_signal_number(exit_signal)
# Get elfutils version
process = subprocess.Popen(
[self.elfutils_path, "--version"],
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
)
elfutils_version, err = process.communicate()
elfutils_version = decode(elfutils_version)
if err:
print(err)
if elfutils_version:
elfutils_version = re.search(
r"eu-unstrip \(elfutils\) (?P<elfutils_version>.*)",
elfutils_version).group("elfutils_version")
# Get OS context
process = subprocess.Popen(
["uname", "-s", "-r"],
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
)
os_context, err = process.communicate()
os_context = decode(os_context)
os_context = re.search(r"(?P<name>.*?) (?P<version>.*)", os_context)
if os_context:
os_name = os_context.group("name")
os_version = os_context.group("version")
else:
os_name = None
os_version = None
process = subprocess.Popen(
["uname", "-a"],
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
)
os_raw_context, err = process.communicate()
os_raw_context = decode(os_raw_context)
# Get App Contex
process = subprocess.Popen(
["file", path_to_core],
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
)
args = app_name = arch = ""
app_context, err = process.communicate()
app_context = decode(app_context)
app_context = re.search(
r"from '.*?( (?P<args>.*))?', .* execfn: '.*\/(?P<app_name>.*?)', platform: '(?P<arch>.*?)'",
app_context,
)
if app_context:
args = app_context.group("args")
app_name = app_context.group("app_name")
arch = app_context.group("arch")
# Make a json from the Thread_list
if thread_list:
for i, thread in enumerate(thread_list):
thread_list[i] = thread.to_json()
# Make the image_list to json
for i, image in enumerate(image_list):
try:
if arch:
image_list[i].arch = arch
image_list[i] = image.to_json()
except:
continue
# Get value, exception from message
message = re.search(
r"(?P<message>.*)\n(?P<value>.*?, (?P<type>.*?)\.)", message)
if message:
value_exception = message.group("value")
type_exception = message.group("type")
message = message.group("message")
if type_exception is None:
type_exception = exit_signal
# Build the json for sentry
sentry_sdk.integrations.modules.ModulesIntegration = None
sentry_sdk.integrations.argv.ArgvIntegration = None
event_id = uuid.uuid4().hex
sdk_name = "coredump.uploader.sdk"
sdk_version = "0.0.1"
data = {
"event_id": event_id,
"timestamp": timestamp,
"platform": "native",
"message": {
"message": message,
},
"exception": {
"value": value_exception,
"type": type_exception,
"thread_id": crashed_thread_id,
"mechanism": {
"type": "coredump",
"handled": False,
"synthetic": True,
"meta": {
"signal": {
"number": exit_signal_number,
"code": None,
"name": exit_signal,
},
},
},
"stacktrace": stacktrace.to_json(),
},
"contexts": {
"gdb": {
"type": "runtime",
"name": "gdb",
"version": gdb_version,
},
"elfutils": {
"type": "runtime",
"name": "elfutils",
"version": elfutils_version,
},
"os": {
"name": os_name,
"version": os_version,
"raw_description": os_raw_context,
},
"runtime": None,
"app": {
"app_name": app_name,
"argv": args,
},
},
"debug_meta": {
"images": image_list
},
"sdk": {
"name": sdk_name,
"version": sdk_version,
},
}
if thread_list:
data["threads"] = {"values": thread_list}
event_id = sentry_sdk.capture_event(data)
print("Core dump sent to sentry: %s" % (event_id))
def send_event(event=None,
post_data=None,
sys_info=None,
additional_tags=None):
"""Send the event to the Sentry server
This method
1. Enable Sentry's sending mechanism.
2. Extend sending event by the information from post_data.
3. Send the event.
4. Disables Sentry's sending mechanism.
Scrubbing the information will be performed in the `_before_send` method.
During the execution of this method, all unhandled exceptions that
will be raised, will be sent to Sentry automatically.
Args:
event: event to send. It should be taken from SentryReporter at
post_data: dictionary made by the feedbackdialog.py
previous stages of executing.
sys_info: dictionary made by the feedbackdialog.py
additional_tags: tags that will be added to the event
Returns:
Event that was sent to Sentry server
"""
SentryReporter._logger.info(f"Send: {post_data}, {event}")
if event is None:
return event
post_data = post_data or dict()
sys_info = sys_info or dict()
additional_tags = additional_tags or dict()
if CONTEXTS not in event:
event[CONTEXTS] = {}
if TAGS not in event:
event[TAGS] = {}
event[CONTEXTS][REPORTER] = {}
# tags
tags = event[TAGS]
tags['version'] = get_value(post_data, 'version')
tags['machine'] = get_value(post_data, 'machine')
tags['os'] = get_value(post_data, 'os')
tags['platform'] = get_first_item(get_value(sys_info, 'platform'))
tags[f'{PLATFORM_DETAILS}'] = get_first_item(
get_value(sys_info, PLATFORM_DETAILS))
tags.update(additional_tags)
# context
context = event[CONTEXTS]
reporter = context[REPORTER]
version = get_value(post_data, 'version')
context['browser'] = {'version': version, 'name': 'Tribler'}
stacktrace_parts = parse_stacktrace(get_value(post_data, 'stack'))
reporter[STACKTRACE] = next(stacktrace_parts, [])
reporter[f'{STACKTRACE}_extra'] = next(stacktrace_parts, [])
reporter[f'{STACKTRACE}_context'] = next(stacktrace_parts, [])
reporter['comments'] = get_value(post_data, 'comments')
reporter[OS_ENVIRON] = parse_os_environ(get_value(
sys_info, OS_ENVIRON))
delete_item(sys_info, OS_ENVIRON)
reporter['events'] = extract_dict(sys_info, r'^(event|request)')
reporter[SYSINFO] = {
key: sys_info[key]
for key in sys_info if key not in reporter['events']
}
with this_sentry_strategy(SentryStrategy.SEND_ALLOWED):
sentry_sdk.capture_event(event)
return event
def await_result(self):
result = self._await_result()
if result["error"] and result["error"]["sentry_event"]:
sentry_sdk.capture_event(result["error"]["sentry_event"])
self.awaiting_input = result["awaiting_input"]
return result
