def test_scrub_kwargs(self, send_payload): def _raise(**kwargs): raise Exception() try: _raise(password='******', clear='text') except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertNotIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) keywords = payload['data']['body']['trace']['frames'][-1]['keywordspec'] self.assertEqual(2, len(payload['data']['body']['trace']['frames'][-1]['locals'][keywords])) self.assertIn('password', payload['data']['body']['trace']['frames'][-1]['locals'][keywords]) self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals'][keywords]['password'], '\*+') self.assertIn('clear', payload['data']['body']['trace']['frames'][-1]['locals'][keywords]) self.assertEqual('text', payload['data']['body']['trace']['frames'][-1]['locals'][keywords]['clear'])
def execute_wrapper(self, query_str, query_params=None): cursor = self.conn.cursor() try: cursor.execute(query_str, query_params) except MySQLError: rollbar.report_exc_info() return cursor
def get_user_by_email(email): """Gets a User by `email` Returns None if not found """ from htk.apps.accounts.models import UserEmail if is_valid_email(email): # check for confirmed email addresses user_emails = UserEmail.objects.filter(email__iexact=email, is_confirmed=True) num_results = user_emails.count() if num_results == 1: user = user_emails[0].user elif num_results > 1: # there should only be one User with this email... # if there are more, we have a data error! raise NonUniqueEmail(email) else: # num_results == 0, so check UserModel for active users with email UserModel = get_user_model() try: user = UserModel.objects.get(email__iexact=email, is_active=True) except UserModel.MultipleObjectsReturned: user = None request = get_current_request() rollbar.report_exc_info() raise NonUniqueEmail(email) except UserModel.DoesNotExist: # also check newly registered accounts # if not user.is_active, handling will get passed downstream user = get_incomplete_signup_user_by_email(email) else: user = None return user
def update_locale_info_by_ip_from_request(self, request): """Update user info by IP Address Store last_login_ip only when logging in Store country resolved from IP Store timezone resolved from IP Caller: api.auth.decorators.register_or_login_user Unknown whether this code throws an exception, but catch it upstream if any """ try: ip = extract_request_ip(request) if ip and self.last_login_ip != ip: self.last_login_ip = ip try: from htk.lib.geoip.utils import get_country_code_by_ip from htk.lib.geoip.utils import get_timezone_by_ip detected_country = get_country_code_by_ip(ip) or '' detected_timezone = get_timezone_by_ip(ip) or '' self.detected_country = detected_country self.detected_timezone = detected_timezone except: # couldn't find geoip records for ip, just be quiet for now pass finally: self.save() except: # error extracting IP or saving rollbar.report_exc_info(request=request)
def crawl_by_url(cls, competition: Competition, url: str) -> int: count = 0 logger = CrawlerLogger.get_logger_for_class(cls) logger.log("crawl {}".format(competition.__str__())) try: tables = cls.get_tables(competition.get_league_url()) for table in tables: for row in table.findAll('tr'): try: if FSRLeagueParser.parse_row(row, competition): count = count + 1 except Exception as e: logger.error(e) rollbar.report_exc_info(sys.exc_info()) except Exception as e: logger.error(e) rollbar.report_exc_info(sys.exc_info()) # TODO: statistics # if lock: # with lock: # self.statistics['teams'] += count # else: # self.statistics['teams'] += count return count
def test_serialize_and_send_payload(self, post=None): invalid_b64 = b'CuX2JKuXuLVtJ6l1s7DeeQ==' invalid = base64.b64decode(invalid_b64) def _raise(): # Make sure that the _invalid local variable makes its # way into the payload even if its value cannot be serialized # properly. _invalid = invalid # Make sure the Password field gets scrubbed even though its # original value could not be serialized properly. Password = invalid password = '******' raise Exception('bug bug') try: _raise() except: rollbar.report_exc_info() self.assertEqual(post.called, True) payload_data = post.call_args[1]['data'] self.assertIsInstance(payload_data, str) self.assertIn('bug bug', payload_data) try: json.loads(post.call_args[1]['data']) except: self.assertTrue(False)
def upload(url, root, env=None, **kwargs): try: if not root: root = os.getcwd() args = dict(commit='', branch='', job='') args.update(kwargs) assert args.get('branch') not in ('', None), "branch is required" assert args.get('commit') not in ('', None), "commit hash is required" assert any((args.get('job'), (args.get('build') and args.get('service') == 'circleci'), args.get('token'))), "missing token or other required argument(s)" reports = build_reports(root) if env: reports = "\n<<<<<< ENV\n".join(("\n".join(["%s=%s" % (k, os.getenv(k, '')) for k in env]), reports)) kwargs['package'] = "codecov-v%s" % VERSION url = "%s/upload/v2?%s" % (url, urlencode(dict([(k, v.strip()) for k, v in kwargs.items() if v is not None]))) result = requests.post(url, data=reports) if result.status_code != 200: sys.stdout.write(result.text) result.raise_for_status() return result.json() except AssertionError as e: rollbar.report_exc_info() return dict(message=str(e), uploaded=False, coverage=0)
def division_lookup(): try: if request.json is None and request.method == 'POST': abort(400, "Must provide JSON (did you set Content-type?)") elif request.method == 'POST': args = request.json else: args = request.args if 'latitude' not in args: abort(400, "Most provide latitude and longitude") if 'longitude' not in args: abort(400, "Most provide latitude and longitude") conn = psycopg2.connect(host=dbcreds.HOSTNAME, database=dbcreds.DATABASE, user=dbcreds.USERNAME, password=dbcreds.PASSWORD) cursor = conn.cursor() cursor.execute(QUERY_FORMAT.format(latitude=float(args['latitude']), longitude=float(args['longitude']))) result = cursor.fetchone() if result is None: name = None else: name = result[0].lower().translate(None, " -'") return jsonify({'division': name}) except: rollbar.report_exc_info() raise
def emit(self, record): if record.exc_info: rollbar.report_exc_info(record.exc_info) else: request = None rollbar.report_message(record.msg, record.levelname, request=request)
def api_call(server, type, data=None): api = get_api(server.address) try: if data: result = api.call(type, data) else: result = api.call(type) except Exception: rollbar.report_exc_info( extra_data={ 'server_id': server.id, 'type': type, 'data': data } ) return None if not result or result.get('result') == API_CALL_RESULTS['exception']: extra_data = { 'server_id': server.id, 'data': data } if result: extra_data['message'] = result.get('message') else: extra_data['message'] = 'No result!' rollbar.report_message('Exception while calling server API', level='error', extra_data=extra_data) return None return result
def application(environ, start_response): try: application = bottle.app() application.catchall = False application = JsonApiMiddleware(application) return application(environ, start_response) except: rollbar.report_exc_info(sys.exc_info(), webob.Request(environ)) # Bare bones 500 handler content = b"" if environ.get("JSON"): content = '{"__status_code__": 500}' content_type = "application/json; charset=UTF-8" else: dirname = os.path.dirname(__file__) five_hundred_path = os.path.join(dirname, "app/html/five_hundred.html") with open(five_hundred_path, "r", encoding="utf-8") as f: content = f.read() content_type = "text/html; charset=UTF-8" content = content.encode("utf-8") start_response( "500 Internal Server Error", [("Content-Type", content_type), ("Content-Length", str(len(content)))], sys.exc_info(), ) environ["wsgi.errors"] = content return [content]
def test_scrub_locals(self, send_payload): invalid_b64 = b'CuX2JKuXuLVtJ6l1s7DeeQ==' invalid = base64.b64decode(invalid_b64) def _raise(): # Make sure that the _invalid local variable makes its # way into the payload even if its value cannot be serialized # properly. _invalid = invalid # Make sure the Password field gets scrubbed even though its # original value could not be serialized properly. Password = invalid password = '******' raise Exception((_invalid, Password, password)) try: _raise() except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals']['password'], '\*+') self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals']['Password'], '\*+') self.assertIn('_invalid', payload['data']['body']['trace']['frames'][-1]['locals']) binary_type_name = 'str' if python_major_version() < 3 else 'bytes' undecodable_message = '<Undecodable type:(%s) base64:(%s)>' % (binary_type_name, base64.b64encode(invalid).decode('ascii')) self.assertEqual(undecodable_message, payload['data']['body']['trace']['frames'][-1]['locals']['_invalid'])
def __call__(self, value): client = kickbox.Client(settings.KICKBOX_API_KEY) kickbox_client = client.kickbox() try: response = kickbox_client.verify(value) except ClientError as e: if e.code == 403 and e.message == 'Insufficient balance': rollbar.report_exc_info(sys.exc_info(), extra_data={'API': 'Kickbox', 'message': e.message}) # send notification notification = KickboxAPIInsuffinetBalanceNotification() EmailAdminsNotificationSender(notification=notification).notify() # and raise ValidationError to mark data as not valid raise InsufficientCreditsError('Kickbox: insufficient balance') raise ValidationError('Kickbox: %s' % e.message) except Exception as e: raise ValidationError('Kickbox: %s' % e.message) else: if response.body['result'] in ('risky', 'undeliverable'): raise ValidationError('Kickbox: email risky or undeliverable') elif response.body['role']: raise ValidationError('Kickbox: email is a role email') elif response.body['free']: raise ValidationError('Kickbox: email address uses free email service') elif response.body['disposable']: raise ValidationError('Kickbox: email address uses a disposable domain') elif response.body['result'] == 'unknown': reason = response.body['reason'] if reason == 'no_connect': raise ValidationError('Kickbox: unable to connect to the SMTP server') else: raise ValidationError('Kickbox: declined for reason "%s"' % reason) return True
def get_story_list(self, batch): """ get a list of stories corresponding to a list of hashes """ req_str = self.nb_endpoint + '/reader/starred_stories?' for a_hash in batch: req_str += 'h=' + a_hash + '&' stories = {} stories_req = requests.Request('GET', req_str, cookies=self.cookies) try: stories = self.request_with_backoff(stories_req) except requests.exceptions.ConnectionError as e: rollbar.report_exc_info() msg = 'Failed to get stories' logger.error(msg) logger.debug('Request string: %s', req_str) logger.error(e) statsd.event(msg, e.message, alert_type='error') logger.debug(stories.text) statsd.increment('nb.http_requests.get') story_list = [] try: story_list = json.loads(stories.text)['stories'] except ValueError as e: rollbar.report_exc_info() msg = 'Failed to parse stories response' logger.error(msg) logger.error(e) statsd.event(msg, e.message, alert_type='error') logger.debug(stories.text) return story_list
def send_new_opportunity_email_to_sellers(brief_json, brief_url): to_email_addresses = [] if brief_json.get('sellerEmail'): to_email_addresses.append(brief_json['sellerEmail']) if brief_json.get('sellerEmailList'): to_email_addresses += brief_json['sellerEmailList'] if to_email_addresses: email_body = render_template( 'emails/seller_new_opportunity.html', brief=brief_json, brief_url=brief_url ) for to_email_address in to_email_addresses: # Send emails individually rather than sending to a list of emails try: send_email( to_email_address, email_body, current_app.config['SELLER_NEW_OPPORTUNITY_EMAIL_SUBJECT'], current_app.config['DM_GENERIC_NOREPLY_EMAIL'], current_app.config['DM_GENERIC_SUPPORT_NAME'], ) except EmailError as e: rollbar.report_exc_info() current_app.logger.error( 'seller new opportunity email failed to send. ' 'error {error}', extra={ 'error': six.text_type(e), }) abort(503, response='Failed to send seller new opportunity email.')
def create_campaign(client, recipients, settings=None): if settings is None: settings = {} settings.update({ 'from_name': 'The Marketplace team', 'reply_to': current_app.config.get('GENERIC_CONTACT_EMAIL') }) try: response = client.campaigns.create( data={ 'type': 'regular', 'recipients': recipients, 'settings': settings } ) current_app.logger.info('Mailchimp campaign {} created with list {}' .format(response['id'], recipients['list_id'])) return response except RequestException as e: current_app.logger.error( 'A Mailchimp API error occurred while creating a campaign, aborting: {} {}'.format(e, e.response)) rollbar.report_exc_info() raise e
def handle_event(event): """Processes a validated skill request from Amazon Alexa Returns a payload if applicable, else None """ event_handler = get_event_handler(event) if event_handler: try: payload = event_handler(event) except: payload = { 'version' : '1.0', 'response' : { 'outputSpeech' : { 'type' : 'SSML', 'ssml' : """<speak>Oops, I couldn't process that.</speak>""", } }, } rollbar.report_exc_info(extra_data={ 'event' : event, 'event_handler' : event_handler.__name__, }) else: payload = None return payload
def test_long_list_arg_val(self, send_payload): def _raise(large): raise Exception() try: xlarge = ['hi' for _ in range(30)] # NOTE(cory): We copy the list here so that the local variables from # this frame are not referenced directly by the frame from _raise() # call above. If we didn't copy this list, Rollbar would report a # circular reference for the args on _raise(). _raise([str(x) for x in xlarge]) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertIn('args', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('kwargs', payload['data']['body']['trace']['frames'][-1]) self.assertEqual(1, len(payload['data']['body']['trace']['frames'][-1]['args'])) self.assertTrue( ("['hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', ...]" == payload['data']['body']['trace']['frames'][-1]['args'][0]) or ("['hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi', ...]" == payload['data']['body']['trace']['frames'][0]['locals']['xlarge']))
def send_activation_email(self, domain=None, resend=False, template=None, subject=None, sender=None): """Sends an activation email """ domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN') self._reset_activation_key(resend=resend) try: should_send_activation_email = True if htk_setting('HTK_ITERABLE_ENABLED'): from htk.lib.iterable.utils import get_iterable_api_client from htk.lib.iterable.utils import get_campaign_id if resend: campaign_key = 'triggered.transactional.account.confirm_email_resend' else: campaign_key = 'triggered.transactional.account.sign_up_confirm_email' itbl_campaign_id = get_campaign_id(campaign_key) if itbl_campaign_id: should_send_activation_email = False data = { 'activation_uri' : self.get_activation_uri(domain=domain), } itbl = get_iterable_api_client() itbl.send_triggered_email(self.email, itbl_campaign_id, data=data) if should_send_activation_email: activation_email(self, domain=domain, template=template, subject=subject, sender=sender) except: request = get_current_request() rollbar.report_exc_info(request=request)
def check_uuids(): num_changed = 0 offset = cache.get(COUNTER_CACHE_NAME) or 0 players = _get_players(offset) if not players: rollbar.report_message('All players checked, check_uuids wrapping around', level='info', extra_data={ 'offset': offset }) offset = 0 players = _get_players(offset) for player in players: try: changed = _handle_player(player) except (IntegrityError, OperationalError): db.session.rollback() rollbar.report_exc_info(level='warning', extra_data={ 'uuid': player.uuid }) else: if changed: num_changed += 1 cache.set(COUNTER_CACHE_NAME, offset + PLAYERS_PER_JOB, 86400) rollbar.report_message('Finished checking uuid group', level='info', extra_data={ 'offset': offset, 'num_changed': num_changed })
def test_anonymous_tuple_args(self, send_payload): # Only run this test on Python versions that support it if not _anonymous_tuple_func: return try: _anonymous_tuple_func((1, (2, 3), 4)) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) self.assertEqual(4, len(payload['data']['body']['trace']['frames'][-1]['argspec'])) self.assertEqual(1, payload['data']['body']['trace']['frames'][-1]['argspec'][0]) self.assertEqual(2, payload['data']['body']['trace']['frames'][-1]['argspec'][1]) self.assertEqual(3, payload['data']['body']['trace']['frames'][-1]['argspec'][2]) self.assertEqual(4, payload['data']['body']['trace']['frames'][-1]['argspec'][3]) self.assertEqual(10, payload['data']['body']['trace']['frames'][-1]['locals']['ret'])
def test_dont_scrub_star_args(self, send_payload): rollbar.SETTINGS['locals']['scrub_varargs'] = False def _raise(*args): raise Exception() try: _raise('sensitive', 'text') except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertNotIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) self.assertIn('locals', payload['data']['body']['trace']['frames'][-1]) varargspec = payload['data']['body']['trace']['frames'][-1]['varargspec'] self.assertEqual(2, len(payload['data']['body']['trace']['frames'][-1]['locals'][varargspec])) self.assertEqual(payload['data']['body']['trace']['frames'][-1]['locals'][varargspec][0], 'sensitive') self.assertEqual(payload['data']['body']['trace']['frames'][-1]['locals'][varargspec][1], 'text')
def test_args_lambda_with_kwargs_and_args_and_defaults(self, send_payload): _raise = lambda arg1, arg2, arg3='default-value', **kwargs: foo(arg1) try: _raise('a1', 'a2', arg3='arg3-value', arg4=2) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) keywords = payload['data']['body']['trace']['frames'][-1]['keywordspec'] # NOTE(cory): again, default values are strange for lambdas and we include them as # positional args. self.assertEqual(3, len(payload['data']['body']['trace']['frames'][-1]['argspec'])) self.assertEqual('arg1', payload['data']['body']['trace']['frames'][-1]['argspec'][0]) self.assertEqual('arg2', payload['data']['body']['trace']['frames'][-1]['argspec'][1]) self.assertEqual('arg3', payload['data']['body']['trace']['frames'][-1]['argspec'][2]) self.assertEqual('a1', payload['data']['body']['trace']['frames'][-1]['locals']['arg1']) self.assertEqual('a2', payload['data']['body']['trace']['frames'][-1]['locals']['arg2']) self.assertEqual('arg3-value', payload['data']['body']['trace']['frames'][-1]['locals']['arg3']) self.assertEqual(1, len(payload['data']['body']['trace']['frames'][-1]['locals'][keywords])) self.assertEqual(2, payload['data']['body']['trace']['frames'][-1]['locals'][keywords]['arg4'])
def test_args_generators(self, send_payload): def _raise(arg1): for i in range(2): if i > 0: raise Exception() else: yield i try: l = list(_raise('hello world')) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) self.assertEqual(1, len(payload['data']['body']['trace']['frames'][-1]['argspec'])) self.assertEqual('arg1', payload['data']['body']['trace']['frames'][-1]['argspec'][0]) self.assertEqual('hello world', payload['data']['body']['trace']['frames'][-1]['locals']['arg1'])
def test_args_lambda_with_star_args_and_args(self, send_payload): _raise = lambda arg1, *args: foo(arg1) try: _raise('arg1-value', 1, 2) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) varargs = payload['data']['body']['trace']['frames'][-1]['varargspec'] self.assertEqual(1, len(payload['data']['body']['trace']['frames'][-1]['argspec'])) self.assertEqual('arg1', payload['data']['body']['trace']['frames'][-1]['argspec'][0]) self.assertEqual('arg1-value', payload['data']['body']['trace']['frames'][-1]['locals']['arg1']) self.assertEqual(2, len(payload['data']['body']['trace']['frames'][-1]['locals'][varargs])) self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals'][varargs][0], '\*+') self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals'][varargs][1], '\*+')
def test_args_lambda_with_kwargs_and_args(self, send_payload): _raise = lambda arg1, arg2, **kwargs: foo(arg1) try: _raise('a1', 'a2', arg3='arg3-value', arg4=2) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertIn('argspec', payload['data']['body']['trace']['frames'][-1]) self.assertNotIn('varargspec', payload['data']['body']['trace']['frames'][-1]) self.assertIn('keywordspec', payload['data']['body']['trace']['frames'][-1]) keywords = payload['data']['body']['trace']['frames'][-1]['keywordspec'] self.assertEqual(2, len(payload['data']['body']['trace']['frames'][-1]['argspec'])) self.assertEqual('arg1', payload['data']['body']['trace']['frames'][-1]['argspec'][0]) self.assertEqual('arg2', payload['data']['body']['trace']['frames'][-1]['argspec'][1]) self.assertEqual('a1', payload['data']['body']['trace']['frames'][-1]['locals']['arg1']) self.assertEqual('a2', payload['data']['body']['trace']['frames'][-1]['locals']['arg2']) self.assertEqual(2, len(payload['data']['body']['trace']['frames'][-1]['locals'][keywords])) self.assertEqual('arg3-value', payload['data']['body']['trace']['frames'][-1]['locals'][keywords]['arg3']) self.assertEqual(2, payload['data']['body']['trace']['frames'][-1]['locals'][keywords]['arg4'])
def store_ballot(): try: if request.json is not None: division = request.json["division"] division_ticket = request.json["division_ticket"] senate_ticket = request.json["senate_ticket"] order_by_group = request.json["order_by_group"] else: division = request.form["division"] division_ticket = request.form["division_ticket"].split(",") senate_ticket = request.form["senate_ticket"].split(",") order_by_group = bool(int(request.form["order_by_group"])) ballot_id = store_at_random_id( { "division": division, "division_ticket": ",".join(str(x) for x in division_ticket), "senate_ticket": ",".join(str(x) for x in senate_ticket), "order_by_group": int(order_by_group), } ) return jsonify({"ballot_id": ballot_id}) except: rollbar.report_exc_info() raise
def test_scrub_self_referencing(self, send_payload): def _raise(obj): raise Exception() try: obj = {} obj['child'] = { 'parent': obj } # NOTE(cory): We copy the dict here so that we don't produce a circular reference # from the _rase() args. _raise(dict(obj)) except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertTrue( (isinstance(payload['data']['body']['trace']['frames'][-1]['locals']['obj'], dict) and 'child' in payload['data']['body']['trace']['frames'][-1]['locals']['obj']) or (isinstance(payload['data']['body']['trace']['frames'][-1]['locals']['obj'], string_types) and payload['data']['body']['trace']['frames'][-1]['locals']['obj'].startswith('<CircularReference')) )
def report_error(): data = {'version': plugin.addon.getAddonInfo('version'), 'platform': platform.system(), 'machine': platform.machine(), 'url': plugin.request.url, 'kodi': kodi_version()} rollbar.report_exc_info(extra_data=data)
def handle_error(request, exception, exc_info): if( isinstance(exception, EXCEPTION_BLACKLIST) and not isinstance(exception, EXCEPTION_WHITELIST) ): return rollbar.report_exc_info(exc_info, request)
def schedule_campaign(client, campaign_id, schedule_time): try: response = client.campaigns.actions.schedule(campaign_id=campaign_id, data={ 'schedule_time': schedule_time }) current_app.logger.info('Mailchimp campaign {} scheduled for {}'.format(campaign_id, schedule_time)) return response except RequestException as e: current_app.logger.error( 'A Mailchimp API error occurred while scheduling campaign {}, aborting: {} {}' .format(campaign_id, e, e.response)) rollbar.report_exc_info() raise e
def gridWeight(entity): """Unimplemented. Ignore for now. """ try: loc = layout.geocode(entity) H() sprint("%s has an importance weight of %s" % (entity.title(), loc.raw['importance'])) return except Exception as e: rollbar.report_exc_info() logging.error(e) gridWeight(entity)
def test_should_add_framework_name_to_payload(self, mock_send_payload, *mocks): import rollbar from rollbar.contrib.asgi.middleware import ReporterMiddleware self.assertIsNone(rollbar.BASE_DATA_HOOK) ReporterMiddleware(None) # invoke integration rollbar.report_exc_info() self.assertTrue(mock_send_payload.called) payload = mock_send_payload.call_args[0][0] self.assertIn('asgi', payload['data']['framework'])
def save(self, user, *args, **kwargs): user = super(ChangePasswordForm, self).save(*args, **kwargs) try: password_changed_email(user) except: from htk.utils.request import get_current_request request = get_current_request() extra_data = { 'user' : user, 'email' : user.profile.confirmed_email or email, } rollbar.report_exc_info(request=request, extra_data=extra_data) return user
def runSlave(self): while True: try: data = self.station_response.recv(1024) if data == 'bye': os.kill(self.child_pid, signal.SIGTERM) print('Received from the server :',str(data.decode('ascii'))) except BlockingIOError: pass except Exception as e: rollbar.report_exc_info() logger.write("Exception raised at " + datetime.datetime.now().strftime("%I:%M%p on %B %d, %Y") + " Reason: " + str(e) + "\n") self.station_response.close()
def delete(finding_id, user_id) -> bool: resp = False try: response = TABLE.delete_item( Key={ 'finding_id': finding_id, 'user_id': user_id } ) resp = response['ResponseMetadata']['HTTPStatusCode'] == 200 except ClientError: rollbar.report_exc_info() return resp
def handler(loop, context): exception = context.get('exception') if exception is not None: exc_info = (type(exception), exception, exception.__traceback__) else: exc_info = None extra_data = { 'csbot_event': context.get('csbot_event'), 'csbot_recent_messages': "\n".join(client.recent_messages), } rollbar.report_exc_info(exc_info, extra_data=extra_data) loop.default_exception_handler(context)
def is_allowed_to_emulate_users(user): """Determines whether `user` is allowed to emulate other users """ allowed = False if user is not None and user.is_authenticated(): try: user_profile = user.profile if user_profile.is_company_officer: allowed = True except: request = get_current_request() rollbar.report_exc_info(request=request) return allowed
def cancel_subscription(self, subscription_id): """Cancels a Subscription for this Customer https://stripe.com/docs/api#cancel_subscription """ subscription = self.retrieve_subscription(subscription_id) if subscription: try: subscription.delete() except stripe.error.InvalidRequestError, e: request = get_current_request() rollbar.report_exc_info(request=request) was_deleted = True
def report_exception(exc_type=None, value=None, tb=None): if exc_type is None: exc_type, value, tb = sys.exc_info() message = ''.join( traceback.format_exception(exc_type, value, tb)) if env.STDOUT_EXCEPTIONS: print(message) logger.exception(message) try: rollbar.report_exc_info(exc_info=(exc_type, value, tb), extra_data={"app": env.APP}) except Exception as e: logger.exception('reporting to rollbar: %s' % e)
async def tick(self): action_type_id = await self.read(1) action_class = BaseAction.get_class_by_type_id(action_type_id) if action_class is None: raise ProtocolError(f'Received unknown Action Type ID [{action_type_id.hex()}]', conn=self) try: await self.handle(await action_class.init(self)) except self.conf.ignore_errors as err: self.close(err) except Exception as err: rollbar.report_exc_info(extra_data=self.identity_scope_user) # FIXME: Use plugins/middleware for this self.close(err)
def create_team(): try: team = team_business.create_team() except TeamError as e: abort(e.message) except NotFoundError as e: return not_found(e.message) except UnauthorisedError as e: return forbidden(e.message) except Exception as e: rollbar.report_exc_info() return jsonify(team)
def parse_given(self, report: str, opts: list[str]) -> DataStatus: """Attempts to parse a given report supplied by the user""" try: data, code = self._parse_given(report, opts) data["meta"] = self.make_meta() except Exception as exc: print("Unknown Parsing Error", exc) rollbar.report_exc_info(extra_data={ "state": "given", "raw": report }) data, code = {"error": ERRORS[1].format(self.report_type)}, 500 return data, code
def _send_to_rollbar(self, level, text, exception, data): if self._rollbar_activated(): try: if exception: rollbar.report_exc_info(sys.exc_info(), extra_data=data, level=level) else: rollbar.report_message(text, level, extra_data=data) except Exception as e: plpy.warning( 'Error sending message/exception to rollbar: {0}'.format( e))
def report_exception(exc_type=None, value=None, tb=None): global project if exc_type is None: exc_type, value, tb = sys.exc_info() stacktrace = ''.join( traceback.format_exception(exc_type, value, tb)) print(stacktrace) logger.exception('Exception: %s' % stacktrace) try: rollbar.report_exc_info(exc_info=(exc_type, value, tb), extra_data={"app": env.project}) except Exception as e: logger.exception('reporting to rollbar: %s' % e)
def authorise_application(id): application = data_api_client.get_application(id) if not can_user_view_application(application): abort(403, 'Not authorised to access application') if is_application_submitted(application): return redirect(url_for('.submit_application', id=id)) application = application['application'] url = url_for('main.render_application', id=id, step='submit', _external=True) user_json = data_api_client.get_user(email_address=application['email']) template = 'emails/create_authorise_email_has_account.html' if not user_json: token_data = { 'id': id, 'name': application['representative'], 'email_address': application['email'] } token = generate_application_invitation_token(token_data) url = url_for('main.render_create_application', token=token, _external=True) template = 'emails/create_authorise_email_no_account.html' email_body = render_template( template, url=url, name=application['representative'], business_name=application['name'], ) try: send_email(application['email'], email_body, current_app.config['AUTHREP_EMAIL_SUBJECT'], current_app.config['INVITE_EMAIL_FROM'], current_app.config['INVITE_EMAIL_NAME']) except EmailError as e: rollbar.report_exc_info() current_app.logger.error( 'Authorisation email failed to send. ' 'error {error}', extra={'error': six.text_type(e)}) abort(503, 'Failed to send user invite reset') return render_template('suppliers/authorisation_submitted.html', name=application['representative'], email_address=application['email'], subject=current_app.config['AUTHREP_EMAIL_SUBJECT'])
async def update_parser(parser: avwx.Report, err_station: "stringable" = None) -> (dict, int): """ Updates the data of a given parser and returns any errors Attempts to fetch five times before giving up """ rtype = parser.__class__.__name__.upper() state_info = { "state": "fetch", "station": parser.station, "source": parser.service } # Update the parser's raw data try: for _ in range(3): try: if not await parser.async_update(timeout=2, disable_post=True): ierr = 0 if isinstance(err_station, str) else 3 return { "error": ERRORS[ierr].format(rtype, err_station) }, 400 break except aio.TimeoutError: pass else: return { "error": ERRORS[5].format(parser.service.__class__.__name__) }, 502 except aio.CancelledError: print("Cancelled Error") return {"error": "Server rebooting. Try again"}, 503 except ConnectionError as exc: print("Connection Error:", exc) rollbar.report_exc_info(extra_data=state_info) return {"error": str(exc)}, 502 except avwx.exceptions.SourceError as exc: print("Source Error:", exc) rollbar.report_exc_info(extra_data=state_info) return {"error": str(exc)}, int(str(exc)[-3:]) except avwx.exceptions.InvalidRequest as exc: print("Invalid Request:", exc) return {"error": ERRORS[0].format(rtype, err_station)}, 400 except Exception as exc: print("Unknown Fetching Error", exc) rollbar.report_exc_info(extra_data=state_info) return {"error": ERRORS[4].format(rtype)}, 500 # Parse the fetched data try: parser._post_update() except avwx.exceptions.BadStation as exc: print("Unknown Station:", exc) return {"error": ERRORS[2].format(parser.station)}, 400 except Exception as exc: print("Unknown Parsing Error", exc) state_info["state"] = "parse" state_info["raw"] = parser.raw rollbar.report_exc_info(extra_data=state_info) return {"error": ERRORS[1].format(rtype), "raw": parser.raw}, 500 return None, None
async def handle_experience_exit_loop(self): while True: logger.debug("Checking current experience state for exit...") try: if (self._current and (await self._current.environment.state()) == EnvironmentState.FAILED): logger.error( "Environment failed, attempting to set current experience to empty..." ) await self.set_experience(None, throttle=5) except Exception as e: rollbar.report_exc_info(e) logger.exception("Error while handling experience exit loop") await asyncio.sleep(1)
def log_audit_event(self, **kwargs): try: audit = AuditEvent( audit_type=kwargs['audit_type'], user=kwargs['user'], data=kwargs['data'], db_object=kwargs['db_object'] ) self.save(audit) except Exception: rollbar.report_exc_info(extra_data={ "audit_type": kwargs['audit_type'], "id": kwargs['db_object'].id })
def redirect_ballot(ballot_id): try: r = redis.StrictRedis(host=REDIS_HOST, db=REDIS_DB) if not r.exists(ballot_id): abort(404) division = r.hget(ballot_id, 'division') url = 'http://belowtheline.org.au/editor/{}#{}'.format( division, ballot_id) return redirect(url) except: rollbar.report_exc_info() raise
def report_error(error, exc_info, request=None, extra_data=None): """Wrapper for error reporting This can be used for store exceptions in error reporting solutions as rollbar while handling error gracefully and giving user cleaner message. """ if HAS_ROLLBAR and hasattr(settings, 'ROLLBAR'): rollbar.report_exc_info(exc_info, request, extra_data=extra_data) weblate.logger.error( 'Handled exception %s: %s', error.__class__.__name__, str(error) )
def _publish_event_batches_to_kinesis(event_batches: List[DialogEventBatch]) -> None: kinesis = get_boto3_client("kinesis") stage = os.environ.get("STAGE") stream_name = f"dialog-event-batches-{stage}" records = [ { "PartitionKey": event_batch.phone_number, "Data": event_batch.json(), } for event_batch in event_batches ] response = kinesis.put_records(StreamName=stream_name, Records=records) if response.get("FailedRecordCount"): rollbar.report_exc_info(extra_data=response)
def debug_error_handler(e): if env == "production": rollbar.report_exc_info() return json_api(InternalServerError, ErrorSchema), 500 else: return ( json_api( InternalServerError( detail=str(e), backtrace=traceback.format_exc().split("\n") ), ErrorSchema, ), 500, )
def short_url(request, code): host = request.get_host() short_url = resolve_short_url_code(host, code) if short_url: try: short_url.record_request(request) except: rollbar.report_exc_info(request=request) url = short_url.url response = redirect(url) else: default_url = 'http://%s' % htk_setting('HTK_CANONICAL_DOMAIN') response = redirect(default_url) return response
def save(self, site, request, commit=True): domain = request.get_host() uri = request.META.get('HTTP_REFERER', '') feedback = super(FeedbackForm, self).save(commit=False) feedback.site = site feedback.uri = uri feedback.save() try: feedback_email(feedback, domain=domain) except: rollbar.report_exc_info(request=request) return feedback
def _parse_given(report_type: str, report: str, opts: [str]) -> (dict, int): """ Attempts to parse a given report supplied by the user """ try: handler = _HANDLE_MAP[report_type]("KJFK") # We ignore the station handler.update(report) resp = asdict(handler.data[0]) resp["meta"] = {"timestamp": datetime.utcnow()} return resp, 200 except Exception as exc: print("Unknown Parsing Error", exc) rollbar.report_exc_info(extra_data={"state": "given", "raw": report}) return {"error": ERRORS[1].format(report_type)}, 500
def send_activation_email(self, domain=None, resend=False, template=None, subject=None, sender=None): """Sends an activation email """ domain = domain or htk_setting('HTK_DEFAULT_EMAIL_SENDING_DOMAIN') self._reset_activation_key(resend=resend) try: should_send_activation_email = True if htk_setting('HTK_ITERABLE_ENABLED'): from htk.lib.iterable.utils import get_iterable_api_client from htk.lib.iterable.utils import get_campaign_id if resend: campaign_key = 'triggered.transactional.account.confirm_email_resend' else: campaign_key = 'triggered.transactional.account.sign_up_confirm_email' itbl_campaign_id = get_campaign_id(campaign_key) if itbl_campaign_id: should_send_activation_email = False data = { 'activation_uri': self.get_activation_uri(domain=domain), } itbl = get_iterable_api_client() itbl.send_triggered_email(self.email, itbl_campaign_id, data=data) if should_send_activation_email: from htk.utils.security import should_use_https use_https = should_use_https() activation_email(self, use_https=use_https, domain=domain, template=template, subject=subject, sender=sender) except: request = get_current_request() rollbar.report_exc_info(request=request)
def update_campaign_content(client, campaign_id, email_body): try: response = client.campaigns.content.update( campaign_id=campaign_id, data={'html': email_body.encode('utf-8')}) current_app.logger.info( 'Content updated for Mailchimp campaign {}'.format(campaign_id)) return response except RequestException as e: current_app.logger.error( 'A Mailchimp API error occurred while updating content for campaign {}, aborting: {} {}' .format(campaign_id, e, e.response)) rollbar.report_exc_info() raise e
def pdf(): try: division_ticket = request.form['division_ticket'].split(',') senate_ticket = request.form['senate_ticket'].split(',') pdf = generate(request.form['division'], division_ticket, request.form['state'], senate_ticket) response = make_response(pdf) response.headers['Content-Type'] = 'application/pdf' response.headers['Content-Disposition'] = \ 'attachment; filename=ballot.pdf' return response except: rollbar.report_exc_info() raise
def login_authenticated_user(request, authenticated_user, backend=None): """Logs in an authenticated user and performs related updates `authenticated_user` has already been authenticated via one of the login backends """ login(request, authenticated_user, backend=backend) authenticated_user.profile.update_locale_info_by_ip_from_request(request) if htk_setting('HTK_ITERABLE_ENABLED'): try: from htk.lib.iterable.utils import get_iterable_api_client itbl = get_iterable_api_client() itbl.notify_login(authenticated_user) except: rollbar.report_exc_info()