def create_app():
if os.environ.get('SENTRY_DSN'):
sentry_init(dsn=os.environ['SENTRY_DSN'],
integrations=[FlaskIntegration()])
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'DATABASE_URL', 'sqlite:///yume.db')
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
try:
with open('.secret_key', 'rb') as f:
app.secret_key = f.read()
except FileNotFoundError:
app.secret_key = os.urandom(64)
f = open('.secret_key', 'wb')
f.write(app.secret_key)
f.close()
app.register_blueprint(api)
app.register_blueprint(game)
db.app = app
db.init_app(app)
babel.app = app
babel.init_app(app)
app.config.update(
CELERY_BROKER_URL=os.environ.get('CELERY_BROKER_URL',
'sqla+sqlite:///yume_broker.db'),
CELERY_RESULT_BACKEND=os.environ.get('CELERY_RESULT_BACKEND',
'db+sqlite:///yume_reuslt.db'))
return app
def _init_sentry(dsn, integrations):
"""Initialise Sentry error tracking.
For details, see:
https://docs.sentry.io/error-reporting/configuration/?platform=python
Args:
dsn (str): Sentry DSN (can be obtained from web console)
integrations (List[sentry.integrations]): frameworks to hook into Sentry client
"""
environment = os.getenv('SCRAPY_PROJECT_ID',
'local') # dependant on `scrapy-jobparameters`
server_name = 'scrapinghub' if is_shub_env() else 'local'
sentry_init(
dsn=dsn,
integrations=integrations,
before_send=_filter_exceptions,
before_breadcrumb=_filter_breadcrumbs,
in_app_include=[application.__package__],
release=application.__version__,
environment=environment,
server_name=server_name,
# request_bodies='always',
# attach_stacktrace=True, # send stacktraces together with log messages
)
def _update_config(self, additional_config):
version = "updatebot-"
version += _run(["git", "rev-parse", "HEAD"],
shell=False,
clean_return=True).stdout.decode().strip()
version += "-dirty" if _run(["[[ -z $(git status -s) ]]"],
shell=True,
clean_return=False).returncode else ""
environment = ""
if "TASK_ID" in os.environ:
environment = "taskcluster"
else:
environment = _run(["hostname"], shell=False,
clean_return=True).stdout.decode().strip()
sentry_init(dsn=self.config['sentry_config']['url'],
debug=self.config['sentry_config']['debug']
if 'debug' in self.config['sentry_config'] else False,
release=version,
max_breadcrumbs=5000,
environment=environment)
with configure_scope() as scope:
if "TASK_ID" in os.environ:
scope.set_extra("TASK_ID", os.environ['TASK_ID'])
def setup(self, app: Application, **options):
"""Initialize Sentry Client."""
super().setup(app, **options)
if not self.cfg.dsn:
return
# Setup Sentry
sentry_init(dsn=self.cfg.dsn, **self.cfg.sdk_options)
def _setup_sentry(self, logger, dsn):
if not SENTRY_IMPORTED:
raise Exception('If specifying SENTRY_DSN, sentry_sdk must be installed'
' (pip install flask-logger[Sentry])')
env = self.config.get('environment') or self.config.get('env')
sentry_init(dsn=dsn, integrations=[FlaskIntegration()], environment=env)
sentry_integration = GLOBAL_HUB.get_integration(LoggingIntegration)
logger.addHandler(sentry_integration._handler) # pylint: disable=protected-access
def _initialize(self):
try:
from sentry_sdk import init as sentry_init
from sentry_sdk import capture_exception as sentry_capture_exception
self._exception_callback = sentry_capture_exception
sentry_init(self.config['url'])
except ImportError:
raise Exception(
'Cannot initialize SentryIO integration, sentry probably not installed'
)
def init(self):
if not self.settings.token:
Logger.log.error('No access token!')
exit()
self.session = VK(self.settings.token)
self.api = self.session.get_api()
if not self.settings.debug and self.settings.sentry_dsn:
sentry_init(self.settings.sentry_dsn, traces_sample_rate=1.0)
Logger.log.info('Sentry initialized!')
for p in self.settings.plugins:
for init in p.init_methods:
Logger.log.debug(f'Init: {p.__class__.__name__}')
init.call()
self.plugins.append(p)
def register_error_handlers(app):
from flask_json import json_response
# - - - - - - - - - - - - - - - - - - - - - - -
@app.errorhandler(BaseError)
def handle_olea_exceptions(e: BaseError):
return json_response(status_=e.http_code, data_=e)
# - - - - - - - - - - - - - - - - - - - - - - -
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations import flask, redis, sqlalchemy
if not app.config.get('IGNORE_ERRORS', False):
sentry_init(dsn=app.config['SENTRY_DSN'],
integrations=[
flask.FlaskIntegration(),
sqlalchemy.SqlalchemyIntegration(),
redis.RedisIntegration(),
],
traces_sample_rate=0.2)
def create_wsgi():
application = FlaskApp(__name__)
config = settings.load_config((
settings.FlaskSettings,
settings.SentrySetting,
))
application.app.config.from_object(config)
CORS(application.app)
application.add_api(specification='v1/openapi.yaml',
resolver=VersionResolver('app.http.v1.handlers'),
strict_validation=True,
validate_responses=True)
@application.app.teardown_appcontext
def shutdown_session(exception):
models.session.remove()
sentry_init(dsn=config.SENTRY_DSN,
integrations=[sentry_flask.FlaskIntegration()])
return application
# coding=utf-8
import os
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations import celery as sentry_celery
from celery import Celery
from . import config
manager = Celery('app')
manager.config_from_object(config)
sentry_init(
dsn=os.getenv('SENTRY_DSN'),
integrations=(sentry_celery.CeleryIntegration(),)
)
from sentry_sdk import init as sentry_init
from app import app
from app.utils.logger import get_logger
from app.utils.config import get_config
SENTRY_DSN = get_config('SENTRY_DSN')
log = get_logger(__name__)
if __name__ == '__main__':
log.info('Starting InventoryService')
if SENTRY_DSN:
sentry_init(SENTRY_DSN)
app.run(host='0.0.0.0', port=5000, debug=get_config('DEBUG', default=False))
class CustomPasswordResetTokenGenerator(PasswordResetTokenGenerator):
"""Custom Password Token Generator Class."""
def _make_hash_value(self, user, timestamp):
# Include user email alongside user password to the generated token
# as the user state object that might change after a password reset
# to produce a token that invalidated.
login_timestamp = '' if user.last_login is None\
else user.last_login.replace(microsecond=0, tzinfo=None)
return str(user.pk) + user.password + user.email +\
str(login_timestamp) + str(timestamp)
default_token_generator = CustomPasswordResetTokenGenerator()
sentry_init(settings.SENTRY_DSN, environment=settings.ENV_ROLE)
User = get_user_model()
def get_or_create_csrf_token(request):
token = request.META.get('CSRF_COOKIE', None)
if token is None:
# Getting a new token
token = csrf.get_token(request)
request.META['CSRF_COOKIE'] = token
request.META['CSRF_COOKIE_USED'] = True
return token
j_print(
"Database backup to S3 is configured.",
host=CONFIG.y("postgresql.s3_backup.host"),
)
# Sentry integration
_ERROR_REPORTING = CONFIG.y_bool("error_reporting.enabled", False)
if not DEBUG and _ERROR_REPORTING:
# pylint: disable=abstract-class-instantiated
sentry_init(
dsn="https://[email protected]/8",
integrations=[
DjangoIntegration(transaction_style="function_name"),
CeleryIntegration(),
RedisIntegration(),
],
before_send=before_send,
release=f"authentik@{__version__}",
traces_sample_rate=0.6,
environment=CONFIG.y("error_reporting.environment", "customer"),
send_default_pii=CONFIG.y_bool("error_reporting.send_pii", False),
)
j_print(
"Error reporting is enabled.",
env=CONFIG.y("error_reporting.environment", "customer"),
)
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.1/howto/static-files/
STATIC_URL = "/static/"
import os
from flask import Flask, render_template
from jinja2 import StrictUndefined
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations.flask import FlaskIntegration
from .extensions import db, migrate
app = Flask(__name__)
app.config.from_object("{{cookiecutter.app_name}}.config")
if app.config.get("JINJA_STRICT_UNDEFINED"):
# Detect undefined jinja variables
app.jinja_env.undefined = StrictUndefined
# Initialize Extensions
db.init_app(app)
migrate.init_app(app, db)
SENTRY_API_KEY = os.environ.get("SENTRY_API_KEY")
if SENTRY_API_KEY:
sentry_init(SENTRY_API_KEY, integrations=[FlaskIntegration()])
@app.route("/")
def index() -> str:
return render_template("index.html")
from flask import Flask
from flask_cors import CORS
from sentry_sdk import init as sentry_init
import config
from database import mongo_client
from log import get_logger
from models.error_handler import error_blueprint
from models.users_handler import users_blueprint
from models.video_handler import video_blueprint
logger = get_logger(__name__)
sentry_init(config.SENTRY_DSN, traces_sample_rate=1.0)
app = Flask(__name__)
CORS(app)
app.register_blueprint(error_blueprint)
app.register_blueprint(users_blueprint)
app.register_blueprint(video_blueprint)
mongo_client.init_app(app, uri=config.MONGO_URI)
@app.route("/")
def home():
return "the server is up & running"
if __name__ == "__main__":
def configure_sentry_logging(dsn: str, environment: str) -> None:
config = build_sentry_configuration(dsn, environment)
sentry_init(**config)
from os import getenv
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations.sanic import SanicIntegration
from sanic import Sanic
from sanic.response import json
sentry_init(
dsn=getenv("SENTRY_DSN"),
integrations=[SanicIntegration()],
)
app = Sanic(__name__)
# noinspection PyUnusedLocal
@app.route("/working")
async def working_path(request):
return json({
"response": "Working API Response"
})
# noinspection PyUnusedLocal
@app.route("/raise-error")
async def raise_error(request):
raise Exception("Testing Sentry Integration")
if __name__ == '__main__':
# https://docs.djangoproject.com/en/1.11/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
SITE_ID = 1
# Sentry integration
if not DEBUG:
sentry_init(
dsn="https://[email protected]/2",
integrations=[
DjangoIntegration(transaction_style="function_name"),
CeleryIntegration(),
],
before_send=before_send,
release='p2@%s' % __version__)
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
STATIC_URL = '/_/static/'
structlog.configure_once(
processors=[
structlog.stdlib.add_log_level,
structlog.stdlib.PositionalArgumentsFormatter(),
structlog.processors.TimeStamper(),
structlog.processors.StackInfoRenderer(),
def disable_sentry_logging() -> None:
sentry_init(dsn=None)
import os
import psycopg2
from psycopg2 import pool
from psycopg2.extras import Json
import requests
import secrets
from sentry_sdk import init as sentry_init
import sys
import time
from traceback import format_exc
import matrix_manager
from pdf_maker import get_pdf_name
from grid import parse_batch, batch_size_from_batch_name
sentry_init('https://[email protected]/8',
environment=os.getenv('SENTRY_ENV', 'dev'),
release=os.getenv('SENTRY_RELEASE', 'unknown'))
from compute_wrapper import get_test_results
"""
App setup, teardown and constants
"""
app = Flask(__name__)
app.secret_key = 'byom-testing-backend'
# Response headers
CONTENT_TYPE = "Content-Type"
CONTENT_JSON = "application/json"
# Using lmdb as a simple K/V store for storing auth tokens and OTP for mobile numbers. Can be replaced by redis once requirements get more complex
SITE_ID = 1
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
STATIC_URL = "/static/"
# Sentry integration
_ERROR_REPORTING = CONFIG.y_bool("error_reporting", False)
if not DEBUG and _ERROR_REPORTING:
sentry_init(
dsn="https://[email protected]/5",
integrations=[
DjangoIntegration(transaction_style="function_name"),
CeleryIntegration(),
RedisIntegration(),
],
before_send=before_send,
release="pyazo@%s" % __version__,
traces_sample_rate=1.0,
send_default_pii=False,
)
print(
dumps({
"event": "Error reporting is enabled.",
"level": "info",
"logger": __name__,
}))
structlog.configure_once(
processors=[
structlog.stdlib.add_log_level,
from envparse import env
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.redis import RedisIntegration
from sentry_sdk.integrations.rq import RqIntegration
from .base import * # noqa
sentry_init(
dsn=env.str("SENTRY_DSN", default=""),
integrations=[DjangoIntegration(), RedisIntegration(), RqIntegration()],
)
POCKET_CONSUMER_KEY = env.str("POCKET_CONSUMER_KEY")
STATICFILES_DIRS = [os.path.join(FRONTEND_DIR, "theme", "dist", "assets")]
from os import getenv
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations.sanic import SanicIntegration
from sanic import Sanic
from sanic.response import json
sentry_init(
dsn=getenv("SENTRY_DSN"),
integrations=[SanicIntegration()],
)
app = Sanic("Example")
# noinspection PyUnusedLocal
@app.route("/working")
async def working_path(request):
return json({"response": "Working API Response"})
# noinspection PyUnusedLocal
@app.route("/raise-error")
async def raise_error(request):
raise Exception("Testing Sentry Integration")
if __name__ == "__main__":
app.run(host="0.0.0.0", port=getenv("PORT", 8080))
from aiohttp import ClientSession
from aiohttp.web import Application, Request, Response, run_app
from cachetools import LRUCache
from gidgethub.sansio import Event
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
from algorithms_keeper.api import GitHubAPI
from algorithms_keeper.event import main_router
cache: MutableMapping[Any, Any] = LRUCache(maxsize=500)
sentry_init(
dsn=os.environ.get("SENTRY_DSN"),
integrations=[
AioHttpIntegration(transaction_style="method_and_path_pattern")
],
)
logging.basicConfig(
format="[%(levelname)s] %(message)s",
level=os.environ.get("LOG_LEVEL", "INFO"),
handlers=[logging.StreamHandler()],
)
logger = logging.getLogger(__package__)
async def main(request: Request) -> Response:
try:
body = await request.read()
# Sentry integration SENTRY_DSN = "https://[email protected]/8" env = get_env() _ERROR_REPORTING = CONFIG.y_bool("error_reporting.enabled", False) if _ERROR_REPORTING: # pylint: disable=abstract-class-instantiated sentry_init( dsn=SENTRY_DSN, integrations=[ DjangoIntegration(transaction_style="function_name"), CeleryIntegration(), RedisIntegration(), Boto3Integration(), ThreadingIntegration(propagate_hub=True), ], before_send=before_send, release=f"authentik@{__version__}", traces_sample_rate=float(CONFIG.y("error_reporting.sample_rate", 0.5)), environment=CONFIG.y("error_reporting.environment", "customer"), send_default_pii=CONFIG.y_bool("error_reporting.send_pii", False), ) set_tag("authentik.build_hash", get_build_hash("tagged")) set_tag("authentik.env", env) set_tag("authentik.component", "backend") set_tag("authentik.uuid", sha512(str(SECRET_KEY).encode("ascii")).hexdigest()[:16]) j_print( "Error reporting is enabled", env=CONFIG.y("error_reporting.environment", "customer"),
SANIC_CONFIG,
CORS_ORIGINS,
SENTRY_DSN,
MODE,
CELERY_BROKER_PASSWORD,
)
from ora_backend.constants import UNCLAIMED_CHATS_PREFIX
# Init Sentry before app creation
if SENTRY_DSN:
sentry_init(
dsn=SENTRY_DSN,
integrations=[
CeleryIntegration(),
RedisIntegration(),
SanicIntegration(),
SqlalchemyIntegration(),
],
request_bodies="always",
send_default_pii=True,
)
# Note: Gino doesn't auto-generate any new changes in the schema
# Use alembic to apply new changes to the db
# (Refer to scripts/migration.sh)
db = Gino()
app = Sanic(__name__)
app.config.update(SANIC_CONFIG)
app.config["JWT_SECRET_KEY"] = JWT_SECRET_KEY
from sentry_sdk import init as sentry_init
from sentry_sdk.integrations import sqlalchemy as sentry_sqlalchemy
from sqlalchemy.engine import create_engine
from app import settings
from ._base import (
Base,
session,
enable_time_logging,
)
from .task import Task
from .user import User
config = settings.load_config(
(settings.SQLAlchemySettings, settings.SentrySetting,)
)
if config.QUERY_TIME_LOGGING:
enable_time_logging(config.QUERY_TIME_THRESHOLD)
engine = create_engine( # pylint: disable=C0103
config.SQLALCHEMY_DATABASE_URI,
convert_unicode=True,
echo=bool(config.SQLALCHEMY_ENGINE_LOG)
)
session.configure(bind=engine)
sentry_init(
dsn=config.SENTRY_DSN,
integrations=(sentry_sqlalchemy.SqlalchemyIntegration(),)
)
#
# if development server enable debugging and load local keys.
if not os.environ.get('SECRET_KEY'):
from flask_debugtoolbar import DebugToolbarExtension
from development_local.local_settings import SECRET_KEY
app.config["SECRET_KEY"] = SECRET_KEY
app.config['SQLALCHEMY_ECHO'] = True
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
DEBUG = DebugToolbarExtension(app)
logging.basicConfig(filename='gastronaut.log', level=logging.WARNING,
format='%(levelname)s:%(asctime)s:%(message)s')
# if production server enable sentry and load environ variables.
else:
sentry_init(
dsn="https://[email protected]/5319947", # NOQA E 501
integrations=[FlaskIntegration(), SqlalchemyIntegration()]
)
app.config["SECRET_KEY"] = os.environ.get('SECRET_KEY')
DEBUG = False
connect_db(app)
#
# 404, 401
#
@app.errorhandler(404)
def page_not_found(e):
