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