def test_error_in_errorhandler(sentry_init, app, capture_events): sentry_init(integrations=[SanicIntegration()]) events = capture_events() @app.route("/error") def myerror(request): raise ValueError("oh no") @app.exception(ValueError) def myhandler(request, exception): 1 / 0 request, response = app.test_client.get("/error") assert response.status == 500 event1, event2 = events exception, = event1["exception"]["values"] assert exception["type"] == "ValueError" assert any(frame["filename"].endswith("test_sanic.py") for frame in exception["stacktrace"]["frames"]) exception = event2["exception"]["values"][-1] assert exception["type"] == "ZeroDivisionError" assert any(frame["filename"].endswith("test_sanic.py") for frame in exception["stacktrace"]["frames"])
async def startup(heliotrope: Heliotrope, loop: AbstractEventLoop) -> None: # DB and http setup heliotrope.ctx.odm = ODM.setup(heliotrope.config.INFO_DB_URL, ) heliotrope.ctx.orm = await ORM.setup(heliotrope.config.GALLERYINFO_DB_URL) heliotrope.ctx.request = await BaseRequest.setup() heliotrope.ctx.hitomi_request = await HitomiRequest.setup( index_file=heliotrope.config.INDEX_FILE) heliotrope.ctx.common_js = await CommonJS.setup( heliotrope.ctx.hitomi_request) # Sentry if heliotrope.config.PRODUCTION: init( heliotrope.config.SENTRY_DSN, integrations=[SanicIntegration()], release=__version__, ) # Task setup supervisor = SuperVisor(heliotrope) if is_the_first_process: supervisor.add_task(MirroringTask.setup, heliotrope.config.MIRRORING_DELAY) supervisor.add_task(RefreshCommonJS.setup, heliotrope.config.REFRESH_COMMON_JS_DELAY) heliotrope.add_task( supervisor.start(heliotrope.config.SUPERVISOR_DELAY))
def test_request_data(sentry_init, app, capture_events): sentry_init(integrations=[SanicIntegration()]) events = capture_events() request, response = app.test_client.get("/message?foo=bar") assert response.status == 200 event, = events assert event["transaction"] == "hi" assert event["request"]["env"] == {"REMOTE_ADDR": ""} assert set(event["request"]["headers"]) == { "accept", "accept-encoding", "host", "user-agent", } assert event["request"]["query_string"] == "foo=bar" assert event["request"]["url"].endswith("/message") assert event["request"]["method"] == "GET" # Assert that state is not leaked events.clear() capture_message("foo") event, = events assert "request" not in event assert "transaction" not in event
def create_app(config: Configuration): app = Sanic(__name__) # Configure Sentry init_sentry( dsn=config.sentry.dsn, environment=config.environment, release=__version__, integrations=[SanicIntegration()], ) @app.listener('before_server_start') async def init(app_, loop): pass @app.listener('after_server_stop') async def close(app_, loop): pass @app.route('/') async def index(_): return response.text(f'python-sanic-example ({__version__})') app.blueprint(view.app) return app
def create_app(config: Configuration): app = Sanic(__name__) # Configure Sentry init_sentry( dsn=config.sentry.dsn, environment=config.environment, release=__version__, integrations=[SanicIntegration()], ) @app.listener('before_server_start') async def init(app_, loop): # pylint: disable=unused-variable pass @app.listener('before_server_stop') async def wait_before_stopping_server(app_, loop): # pylint: disable=unused-variable await asyncio.sleep(config.before_graceful_termination) @app.listener('after_server_stop') async def close(app_, loop): # pylint: disable=unused-variable pass @app.route('/') async def index(_): # pylint: disable=unused-variable return response.text( f'{{ cookiecutter.project_name }} ({__version__})') app.blueprint(view.app) return app
def _preload_server(self): if self.config.driver.sentry_dsn: sentry_sdk.init( dsn=self.config.driver.sentry_dsn, integrations=[SanicIntegration()], environment=self.config.driver.sentry_env ) self._sanic = Sanic(name=self.name, log_config=get_logging_config(self.config.app)) self._sanic.config = self.config.driver.get_sanic_config()
def test_bad_request_not_captured(sentry_init, app, capture_events): sentry_init(integrations=[SanicIntegration()]) events = capture_events() @app.route("/") def index(request): abort(400) request, response = app.test_client.get("/") assert response.status == 400 assert not events
def build_app(): from config import config sentry_sdk.init(dsn=config.SENTRY_DSN, integrations=[SanicIntegration()], release=VERSION, environment=os.environ.get( 'INFOENERGIA_MODULE_SETTINGS').split('.')[-1]) app = Sanic('infoenergia-api') try: app.config.from_object(config) InitializeJWT(app, authenticate=authenticate, retrieve_user=retrieve_user, class_views=extra_views) app.blueprint(bp_contracts) app.blueprint(bp_f1_measures) app.blueprint(bp_modcontracts) app.blueprint(bp_cch_measures) app.blueprint(bp_reports) app.blueprint(bp_tariff) app.add_route(InvitationUrlToken.as_view(), '/auth/invitationtoken', host='localhost:9000') app.thread_pool = futures.ThreadPoolExecutor(app.config.MAX_THREADS) app.erp_client = Client(transport=PoolTransport( secure=app.config.TRANSPORT_POOL_CONF['secure']), **app.config.ERP_CONF) db.bind(provider='sqlite', filename=os.path.join( app.config.DATA_DIR, '{}.sqlite3'.format(app.config.DB_CONF['database'])), create_db=True) db.generate_mapping(create_tables=True) app.db = db except Exception as e: msg = "An error ocurred building Infoenergia API: %s" logger.exception(msg, str(e)) raise e else: logger.info("Build api finished") return app
def _preload_server(self): if self.config.driver.sentry_dsn: sentry_kwargs = dict( dsn=self.config.driver.sentry_dsn, integrations=[SanicIntegration()], environment=self.config.driver.sentry_env, release=self.config.driver.version, ignore_errors=self.config.driver.sentry_ignore_errors, **self.config.driver.sentry_kwargs, ) sentry_kwargs.update(self.config.driver.sentry_kwargs) sentry_sdk.init(**sentry_kwargs) self._sanic = Sanic(name=self.name, log_config=get_logging_config(self.config.app)) self._sanic.config = self.config.driver.get_sanic_config()
def test_concurrency(sentry_init, app): sentry_init(integrations=[SanicIntegration()]) @app.route("/context-check/<i>") async def context_check(request, i): with configure_scope() as scope: scope.set_tag("i", i) await asyncio.sleep(random.random()) with configure_scope() as scope: assert scope._tags["i"] == i return response.text("ok") async def task(i): responses = [] await app.handle_request( request.Request( url_bytes="http://localhost/context-check/{i}".format( i=i).encode("ascii"), headers={}, version="1.1", method="GET", transport=None, ), write_callback=responses.append, stream_callback=responses.append, ) r, = responses assert r.status == 200 async def runner(): await asyncio.gather(*(task(i) for i in range(1000))) if sys.version_info < (3, 7): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.run_until_complete(runner()) else: asyncio.run(runner()) with configure_scope() as scope: assert not scope._tags
def create_app(): app = Sanic(__name__) # ------------------------------------------------------------------------ # CONFIGURATION # ------------------------------------------------------------------------ init(dsn=config('SENTRY_DSN'), integrations=[SanicIntegration()]) app.blueprint(initdb_blueprint) app.blueprint(oauth_blueprint) app.blueprint(auth_blueprint) app.blueprint(form_blueprint) app.blueprint(api_retrieve_blueprint) app.blueprint(api_create_blueprint) app.blueprint(api_update_blueprint) app.blueprint(api_delete_blueprint) app.blueprint(api_switch_blueprint) app.blueprint(api_redirect_blueprint) app.blueprint(view_blueprint) app.blueprint(extra_blueprint) app.static('/links/', './static/') app.config.WTF_CSRF_SECRET_KEY = config('WTF_CSRF_SECRET_KEY') # ------------------------------------------------------------------------ # AUTHENTICATION # ------------------------------------------------------------------------ app.session_interface = InMemorySessionInterface() app.config.OAUTH_PROVIDER = config('OAUTH_PROVIDER') app.config.OAUTH_SCOPE = config('OAUTH_SCOPE') app.config.OAUTH_CLIENT_ID = config('OAUTH_CLIENT_ID') app.config.OAUTH_CLIENT_SECRET = config('OAUTH_CLIENT_SECRET') if config('PRODUCTION', default=False, cast=bool): domain = config('DOMAIN_NAME') else: domain = config('LOCAL_HOST') app.config.OAUTH_REDIRECT_URI = domain + config('OAUTH_REDIRECT_ENDPOINT') app.register_middleware(add_session_to_request, 'request') app.register_middleware(save_session, 'response') return app
def test_errors(sentry_init, app, capture_events): sentry_init(integrations=[SanicIntegration()]) events = capture_events() @app.route("/error") def myerror(request): raise ValueError("oh no") request, response = app.test_client.get("/error") assert response.status == 500 event, = events assert event["transaction"] == "myerror" exception, = event["exception"]["values"] assert exception["type"] == "ValueError" assert exception["value"] == "oh no" assert any(frame["filename"].endswith("test_sanic.py") for frame in exception["stacktrace"]["frames"])
async def before_server_start(app: Sanic): """ Before server start @param app: @return: """ DatabaseEngineManager.create_engines( primary_db_urls=[app.config["PRIMARY_DB_URL"]], replica_db_urls=[app.config["REPLICA_DB_URL"]], ) app.db_client = DatabaseClient() app.redis_client = await aioredis.create_redis_pool(app.config["REDIS_URL"] ) sentry_sdk.init( dsn=app.config["SENTRY_DSN"], environment=app.config["ENV"], integrations=[ SanicIntegration(), AioHttpIntegration(), SqlalchemyIntegration(), ], )
def start(self, deamon=True, port=None, debug=False): user = getpass.getuser() if user != self.__shell_user: raise ValueError( f"{user} not autorized, use {self.__shell_user} instead") if port: self.__port = port print("Start Runner", __version__) try: if os.environ.get("NAAS_SENTRY_DSN"): sentry_sdk.init( dsn=os.environ.get("NAAS_SENTRY_DSN"), traces_sample_rate=1.0, environment=escape_kubernet(self.__user), integrations=[SanicIntegration()], ) sentry_sdk.set_user({"email": self.__user}) with sentry_sdk.configure_scope() as scope: scope.set_context("Naas", {"version": __version__}) self.__main(debug) except KeyboardInterrupt: print("Shutdown server") sys.exit()
def test_concurrency(sentry_init, app): """ Make sure we instrument Sanic in a way where request data does not leak between request handlers. This test also implicitly tests our concept of how async code should be instrumented, so if it breaks it likely has ramifications for other async integrations and async usercode. We directly call the request handler instead of using Sanic's test client because that's the only way we could reproduce leakage with such a low amount of concurrent tasks. """ sentry_init(integrations=[SanicIntegration()]) @app.route("/context-check/<i>") async def context_check(request, i): with configure_scope() as scope: scope.set_tag("i", i) await asyncio.sleep(random.random()) with configure_scope() as scope: assert scope._tags["i"] == i return response.text("ok") async def task(i): responses = [] kwargs = { "url_bytes": "http://localhost/context-check/{i}".format(i=i).encode( "ascii" ), "headers": {}, "version": "1.1", "method": "GET", "transport": None, } if SANIC_VERSION >= (19,): kwargs["app"] = app await app.handle_request( request.Request(**kwargs), write_callback=responses.append, stream_callback=responses.append, ) r, = responses assert r.status == 200 async def runner(): await asyncio.gather(*(task(i) for i in range(1000))) if sys.version_info < (3, 7): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.run_until_complete(runner()) else: asyncio.run(runner()) with configure_scope() as scope: assert not scope._tags
import sentry_sdk from sentry_sdk.integrations.sanic import SanicIntegration from tortoise import Tortoise import config # 初始化数据库 async def init_db(create_db=False): await Tortoise.init(db_url=config.DB_URL, modules={'models': ['app.models']}, _create_db=create_db) sentry_sdk.init(dsn=config.SENTRY_DSN, integrations=[SanicIntegration()])
from django.conf import settings import sentry_sdk from sentry_sdk.integrations.celery import CeleryIntegration from sentry_sdk.integrations.django import DjangoIntegration from sentry_sdk.integrations.redis import RedisIntegration from sentry_sdk.integrations.flask import FlaskIntegration from sentry_sdk.integrations.aiohttp import AioHttpIntegration from sentry_sdk.integrations.sanic import SanicIntegration if not settings.DEBUG: sentry_sdk.init( "https://[email protected]/1471674", environment=settings.SENTRY_ENVIRONMENT, integrations=[ CeleryIntegration(), DjangoIntegration(), RedisIntegration(), FlaskIntegration(), AioHttpIntegration(), SanicIntegration(), ], release=os.getenv("RELEASE", None), traces_sample_rate=1.0, ) try: application = get_wsgi_application() except Exception as e: print(e) traceback.print_exc()
app.conn.use("magiccap") await app.create_table_if_not_exists("uploads") await app.create_table_if_not_exists("installs") await app.create_s3_client() app = RethinkSanic(__name__) # Defines the app. CORS(app) # Allows CORS. sentry_sdk.init(dsn=os.environ['SENTRY_DSN'], integrations=[SanicIntegration()]) # Loads in Sentry. @app.route("/") async def root_redirect(_): """Redirects to magiccap.me.""" return response.redirect("https://magiccap.me") @app.route("/healthcheck") async def healthcheck(_): """A simple healthcheck.""" return response.json(200)
def test_concurrency(sentry_init, app): """ Make sure we instrument Sanic in a way where request data does not leak between request handlers. This test also implicitly tests our concept of how async code should be instrumented, so if it breaks it likely has ramifications for other async integrations and async usercode. We directly call the request handler instead of using Sanic's test client because that's the only way we could reproduce leakage with such a low amount of concurrent tasks. """ sentry_init(integrations=[SanicIntegration()]) @app.route("/context-check/<i>") async def context_check(request, i): with configure_scope() as scope: scope.set_tag("i", i) await asyncio.sleep(random.random()) with configure_scope() as scope: assert scope._tags["i"] == i return response.text("ok") async def task(i): responses = [] kwargs = { "url_bytes": "http://localhost/context-check/{i}".format(i=i).encode( "ascii" ), "headers": {}, "version": "1.1", "method": "GET", "transport": None, } if SANIC_VERSION >= (19,): kwargs["app"] = app if SANIC_VERSION >= (21, 3): try: app.router.reset() app.router.finalize() except AttributeError: ... class MockAsyncStreamer: def __init__(self, request_body): self.request_body = request_body self.iter = iter(self.request_body) self.response = b"success" def respond(self, response): responses.append(response) patched_response = HTTPResponse() patched_response.send = lambda end_stream: asyncio.sleep(0.001) return patched_response def __aiter__(self): return self async def __anext__(self): try: return next(self.iter) except StopIteration: raise StopAsyncIteration patched_request = request.Request(**kwargs) patched_request.stream = MockAsyncStreamer([b"hello", b"foo"]) await app.handle_request( patched_request, ) else: await app.handle_request( request.Request(**kwargs), write_callback=responses.append, stream_callback=responses.append, ) (r,) = responses assert r.status == 200 async def runner(): await asyncio.gather(*(task(i) for i in range(1000))) if sys.version_info < (3, 7): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.run_until_complete(runner()) else: asyncio.run(runner()) with configure_scope() as scope: assert not scope._tags
UserService, ) from src.utils import AcquityJson if APP_CONFIG["SENTRY_ENABLE"]: def sentry_before_send(event, hint): if "exc_info" in hint: _exc_type, exc_value, _tb = hint["exc_info"] if isinstance(exc_value, AcquityException): return None return event sentry_sdk.init( dsn="https://[email protected]/1800796", integrations=[SanicIntegration(), SqlalchemyIntegration()], before_send=sentry_before_send, ) app = Sanic(load_env=False) app.config.update(APP_CONFIG) sio = socketio.AsyncServer( async_mode="sanic", cors_allowed_origins=[], json=AcquityJson ) sio.attach(app) sio.register_namespace(ChatSocketService("/v1/chat", app.config)) app.user_service = UserService(app.config) app.sell_order_service = SellOrderService(app.config) app.buy_order_service = BuyOrderService(app.config)
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import asyncio import sentry_sdk import uvloop from sentry_sdk.integrations.sanic import SanicIntegration from sentry_sdk.integrations.aiohttp import AioHttpIntegration from . import Server from .logging import fix_access_log, setup_logging sentry_sdk.init( dsn= "https://[email protected]/5921973", integrations=[SanicIntegration(), AioHttpIntegration()], request_bodies="always", traces_sample_rate=1.0) asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) with setup_logging(): fix_access_log() Server.with_config().run()