async def cli(ctx, config: List[str], logging_config: str):
try:
path = join(os.getcwd(), logging_config)
_logging_config = LoggingConfig.load(path)
except FileNotFoundError:
path = join(dirname(__file__), 'configs', logging_config)
_logging_config = LoggingConfig.load(path)
_logging_config.apply()
_config = DipDupConfig.load(config)
if _config.spec_version not in spec_version_to_version:
raise ConfigurationError('Unknown `spec_version`')
if _config.spec_version != __spec_version__ and ctx.invoked_subcommand != 'migrate':
migration_required(_config.spec_version, __spec_version__)
if _config.sentry:
sentry_sdk.init(
dsn=_config.sentry.dsn,
integrations=[AioHttpIntegration()],
)
ctx.obj = CLIContext(
config_paths=config,
config=_config,
logging_config=_logging_config,
)
async def test_post_body_not_read(sentry_init, aiohttp_client, loop,
capture_events):
from sentry_sdk.integrations.aiohttp import BODY_NOT_READ_MESSAGE
sentry_init(integrations=[AioHttpIntegration()])
body = {"some": "value"}
async def hello(request):
1 / 0
app = web.Application()
app.router.add_post("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.post("/", json=body)
assert resp.status == 500
event, = events
exception, = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
request = event["request"]
assert request["env"] == {"REMOTE_ADDR": "127.0.0.1"}
assert request["method"] == "POST"
assert request["data"] == BODY_NOT_READ_MESSAGE
async def test_traces_sampler_gets_request_object_in_sampling_context(
sentry_init,
aiohttp_client,
DictionaryContaining, # noqa:N803
ObjectDescribedBy, # noqa:N803
):
traces_sampler = mock.Mock()
sentry_init(
integrations=[AioHttpIntegration()],
traces_sampler=traces_sampler,
)
async def kangaroo_handler(request):
return web.Response(text="dogs are great")
app = web.Application()
app.router.add_get("/tricks/kangaroo", kangaroo_handler)
client = await aiohttp_client(app)
await client.get("/tricks/kangaroo")
traces_sampler.assert_any_call(
DictionaryContaining({
"aiohttp_request":
ObjectDescribedBy(type=Request,
attrs={
"method": "GET",
"path": "/tricks/kangaroo"
})
}))
async def test_basic(sentry_init, aiohttp_client, loop, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
async def hello(request):
1 / 0
app = web.Application()
app.router.add_get("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.get("/")
assert resp.status == 500
event, = events
exception, = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
request = event["request"]
host = request["headers"]["Host"]
assert request["env"] == {"REMOTE_ADDR": "127.0.0.1"}
assert request["method"] == "GET"
assert request["query_string"] == ""
assert request["url"] == f"http://{host}/"
assert request["headers"] == {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": host,
"User-Agent": request["headers"]["User-Agent"],
}
async def test_post_body_read(sentry_init, aiohttp_client, loop,
capture_events):
sentry_init(integrations=[AioHttpIntegration()])
body = {"some": "value"}
async def hello(request):
await request.json()
1 / 0
app = web.Application()
app.router.add_post("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.post("/", json=body)
assert resp.status == 500
(event, ) = events
(exception, ) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
request = event["request"]
assert request["env"] == {"REMOTE_ADDR": "127.0.0.1"}
assert request["method"] == "POST"
assert request["data"] == json.dumps(body)
def run(self):
try:
sentry_sdk.init(
Tokens.sentry_link.value,
traces_sample_rate=1.0,
integrations=[
AioHttpIntegration(),
ThreadingIntegration(),
LoggingIntegration(),
ModulesIntegration(),
],
)
log.info("Sentry Setup Done")
log.info("Bot will now start")
super().run(Tokens.token.value, reconnect=True)
except discord.PrivilegedIntentsRequired:
log.critical(
"[Login Failure] You need to enable the server members intent on the Discord Developers Portal."
)
except discord.errors.LoginFailure:
log.critical(
"[Login Failure] The token initialsed in environment(or .env file) is invalid."
)
except KeyboardInterrupt:
log.critical(
"The bot is shutting down since force shutdown was initiated.")
except Exception as e:
log.critical("An exception occured, %s", e)
def init_app(checks: Checks):
app = web.Application(
middlewares=[middleware.error_middleware, middleware.request_summary])
sentry_sdk.init(dsn=config.SENTRY_DSN, integrations=[AioHttpIntegration()])
app["poucave.cache"] = utils.Cache()
app["poucave.checks"] = checks
app.add_routes(routes)
app.router.add_static("/html/",
path=HTML_DIR,
name="html",
show_index=True)
# Enable CORS on all routes.
cors = aiohttp_cors.setup(
app,
defaults={
config.CORS_ORIGINS:
aiohttp_cors.ResourceOptions(allow_credentials=True,
expose_headers="*",
allow_headers="*")
},
)
for route in list(app.router.routes()):
cors.add(route)
return app
def setup(app: Application,
app_name: str,
config: AppConfig,
package_name: Optional[str] = None) -> None:
if not package_name:
package_name = app_name
app["config"] = config
app["app_name"] = app_name
app["hostname"] = socket.gethostname()
app["distribution"] = pkg_resources.get_distribution(package_name)
if config.sentry_dsn:
sentry_sdk.init(
dsn=str(config.sentry_dsn),
integrations=[AioHttpIntegration()],
release=app["distribution"].version,
)
with sentry_sdk.configure_scope() as scope:
scope.set_tag("app_name", app["app_name"])
app.middlewares.append(common_middleware) # type: ignore
app.router.add_get("/-/health", meta.health, name="health")
app.router.add_get("/-/meta", meta.index, name="meta")
def main(argv: list):
sentry_sdk.init(
"https://[email protected]/5406178",
traces_sample_rate=1.0,
integrations=[
AioHttpIntegration(),
LoggingIntegration(
level=logging.INFO, # Capture info and above as breadcrumbs
event_level=logging.ERROR, # Send errors as events
),
],
)
debug = False
def show_help():
print("-D or --DEBUG to debug")
try:
opts, args = getopt.getopt(argv, "hD", ["help", "DEBUG"])
except getopt.GetoptError:
show_help()
sys.exit(2)
for opt, arg in opts:
if opt == "-h":
show_help()
sys.exit()
elif opt in ("-D", "--DEBUG"):
debug = True
create_app(debug)
def run(top_parser: ArgumentParser,
input_args: Optional[List[str]] = None) -> None:
args = top_parser.parse_args(input_args)
loop = asyncio.get_event_loop()
sentry_url = os.environ.get('SENTRY_URL')
if sentry_url:
sentry_sdk.init(dsn=sentry_url, integrations=[AioHttpIntegration()])
handler = getattr(args, 'handler', None)
if handler is None:
top_parser.print_help()
else:
loop.add_signal_handler(signal.SIGTERM, on_term_sig)
try:
loop.run_until_complete(handler.run(args))
if getattr(handler, 'run_forever', False):
loop.run_forever()
except KeyboardInterrupt:
pass
except RuntimeError as e:
if 'Event loop stopped before Future completed' not in str(e):
raise
handler.shutdown()
def load(cls, env_prefix: str = 'TG_ODESLI_BOT_'):
"""Load config merging default variables and environment variables.
:param env_prefix: prefix for environment variables
:return: filled config object
"""
config = cls()
# Load environment from .env file
dotenv.load_dotenv()
# Update config object with environment variables
for env_var_name, value in os.environ.items():
if env_var_name.startswith(env_prefix):
var_name = env_var_name[len(env_prefix):]
# Do not override config vars in testing mode
if hasattr(config, 'TESTING') and hasattr(config, var_name):
continue
setattr(config, var_name, value)
if config.SENTRY_DSN:
sentry_sdk.init(
dsn=config.SENTRY_DSN,
integrations=[AioHttpIntegration()],
environment=config.SENTRY_ENVIRONMENT,
)
if not structlog.is_configured():
config.init_logging()
return config
def main():
"""Entry point for poetry script."""
sentry_sdk.init(
SENTRY_URL,
release=Repo().head.object.hexsha,
integrations=[AioHttpIntegration()],
)
bot.run(BOT_TOKEN)
def configure_sentry() -> None:
"""Configure sentry client from config files."""
sentry_sdk.init(
dsn=config["sentry"]["dsn"],
integrations=[
LoggingIntegration(level=logging.INFO, event_level=logging.ERROR),
AioHttpIntegration(),
],
)
def initialize_sentry(sentry_env):
import sentry_sdk
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
sentry_sdk.init(
dsn=
"https://[email protected]/5768574",
integrations=[AioHttpIntegration()],
environment=sentry_env)
def initialize_sentry(sentry_env):
import sentry_sdk
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
sentry_sdk.init(
dsn=
"https://[email protected]/5768575",
integrations=[AioHttpIntegration()],
environment=sentry_env)
def install(app):
if not app.config.sentry_dsn:
raise ValueError('You need to set `sentry_dsn` plugin option to use `sentry` plugin')
sentry_sdk.init(
app.config.sentry_dsn,
environment=os.environ.get('APP_MODE', 'dev'),
integrations=[AioHttpIntegration()],
release=app.config.version
)
app.sentry = sentry_sdk
def initialize_sentry(sentry_env):
import sentry_sdk
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
sentry_sdk.init(
dsn=
"https://[email protected]/5283135",
integrations=[AioHttpIntegration()],
environment=sentry_env,
)
def main():
if config.get("sentry"):
sentry_sdk.init(dsn=config["sentry"]["dns"],
integrations=[AioHttpIntegration()])
signal.signal(signal.SIGINT, handle_sigint)
loop = asyncio.get_event_loop()
loop.run_until_complete(init(config))
def setup_sentry() -> None:
"""Set up the Sentry logging integrations."""
sentry_logging = LoggingIntegration(level=logging.DEBUG,
event_level=logging.WARNING)
sentry_sdk.init(dsn=constants.Bot.sentry_dsn,
integrations=[
sentry_logging,
AioHttpIntegration(),
RedisIntegration(),
])
def initialize_sentry(sentry_env):
import sentry_sdk
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
sentry_sdk.init(
dsn=
"https://[email protected]/5376966",
integrations=[SqlalchemyIntegration(),
AioHttpIntegration()],
environment=sentry_env)
def init_sentry(sentry_cfg: Dict[str, Any]):
if sentry_sdk is None:
raise ImportError("`sentry` extra is not installed")
log.debug("Initializing Sentry...")
release = f"royalnet@{semantic}"
sentry_sdk.init(sentry_cfg["dsn"],
integrations=[AioHttpIntegration(),
SqlalchemyIntegration(),
LoggingIntegration(event_level=None)],
release=release)
log.info(f"Sentry: {release}")
def main():
sentry_dsn = os.getenv('SENTRY_DSN')
if sentry_dsn:
sentry_sdk.init(dsn=sentry_dsn,
environment="dcatd",
integrations=[AioHttpIntegration()],
ignore_errors=['HTTPTemporaryRedirect'])
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
aio_app = application.Application()
web.run_app(aio_app, port=aio_app.config['web']['port'])
return 0
def __init__(self):
super().__init__(
command_prefix=get_prefix,
description='The number 1 wanna be meme bot',
case_insensitive=True,
allowed_mentions=discord.AllowedMentions(
roles=False,
everyone=False)
)
with open('./dagbot/data/credentials.yml', 'r') as file:
self.data = yaml.load(file, Loader=yaml.FullLoader)
self.launch_time = None
self.session = None
self.pg_con = None
self.caching = caching(self)
self.dagpi = Client(self.data['dagpitoken'])
self.bwordchecker = bword()
self.bwordchecker.loadbword()
self.useage = {}
self.commands_called = 0
# self.add_cog(Help(bot))
self.load_extension("jishaku")
extensions = [
"text", "fun", "newimag",
"reddit", "games", "util",
"whysomart", "animals", "memes",
"tags", "misc", "settings",
"ai", "events", "errors",
"developer", "help"
]
for extension in extensions:
try:
self.load_extension(f"extensions.{extension}")
print(f"loaded extension {extension}")
except Exception as error:
print(f"{extension} cannot be loaded due to {error}")
self.before_invoke(self.starttyping)
self.after_invoke(self.exittyping)
self.loop.create_task(self.startdagbot())
self.sentry = sentry_sdk.init(
dsn=self.data['sentryurl'],
integrations=[AioHttpIntegration()]
)
self.run(self.data['token'])
def __init__(self):
super().__init__(command_prefix=get_prefix,
description='The number 1 wanna be meme bot',
case_insensitive=True,
max_messages=100,
strip_after_prefix=True,
allowed_mentions=discord.AllowedMentions(
roles=False, everyone=False),
intents=make_intents())
self.logger = create_logger("Dagbot", logging.DEBUG)
self.discprd_logger = create_logger('discord', logging.INFO)
with open('./configuration.yml', 'r') as file:
self.data = yaml.load(file, Loader=yaml.FullLoader)
self.data.pop("PWD")
self.logger.info("Loaded Config File")
self.launch_time = None
self.session = None
self.pool = None
self.dagpi = None
self.repo = "https://github.com/Daggy1234/dagbot"
self.caching = Caching(self)
self.bwordchecker = bword()
self.bwordchecker.loadbword()
self.useage = {}
self.commands_called = 0
# self.add_cog(Help(bot))
self.load_extension("jishaku")
extensions = [
"text", "fun", "newimag", "reddit", "games", "util", "whysomart",
"animals", "memes", "tags", "misc", "settings", "ai", "events",
"errors", "developer", "help", "automeme", "uploader"
]
for extension in extensions:
try:
self.load_extension(f"dagbot.extensions.{extension}")
self.logger.info(f"loaded extension {extension}")
except Exception as error:
self.logger.critical(
f"{extension} cannot be loaded due to {error}")
self.before_invoke(self.starttyping)
self.logger.info("Initialising Stuff")
self.loop.create_task(self.startdagbot())
self.socket_stats = {}
self.sentry = sentry_sdk.init(dsn=self.data['sentryurl'],
integrations=[AioHttpIntegration()],
release="[email protected]")
self.logger.info("Ready to roll")
def get_app(self) -> web.Application:
sentry_sdk.init(
dsn=self.config['sentry_dsn'],
integrations=[AioHttpIntegration(),
SqlalchemyIntegration()])
app = web.Application(
middlewares=[error_middleware, validation_middleware, self.db])
self.init_clients(app)
self.init_postgres(app)
self.init_routes(app)
app.on_response_prepare.append(prepare_cors)
app.on_shutdown.append(self.stop)
return app
def setup(app, dsn, env="dev", level=logging.ERROR, event_level=logging.ERROR):
sentry_sdk.init(
dsn=dsn,
environment=env,
integrations=[
LoggingIntegration(
level=level, # Capture level and above as breadcrumbs
event_level=event_level, # Send event_level and above as events
),
AioHttpIntegration(),
],
)
def initialise_sentry():
global sentry_initialised
if os.environ.get("SENTRY_DSN", "") and not sentry_initialised:
sentry_sdk.init(
os.environ.get("SENTRY_DSN"),
integrations=[
AwsLambdaIntegration(),
FlaskIntegration(),
AioHttpIntegration(),
],
traces_sample_rate=0.01,
)
sentry_initialised = True
def setup_diagnostics(coresys: CoreSys) -> None:
"""Sentry diagnostic backend."""
sentry_logging = LoggingIntegration(level=logging.WARNING,
event_level=logging.CRITICAL)
_LOGGER.info("Initialize Supervisor Sentry")
sentry_sdk.init(
dsn=
"https://[email protected]/5370612",
before_send=lambda event, hint: filter_data(coresys, event, hint),
max_breadcrumbs=30,
integrations=[AioHttpIntegration(), sentry_logging],
release=SUPERVISOR_VERSION,
)
def create_app():
configure_logging(level=CONFIG.log_level)
backdoor.setup()
if CONFIG.sentry_enable:
sentry_sdk.init(
dsn=CONFIG.sentry_dsn,
integrations=[AioHttpIntegration()]
)
api = web.Application()
api.router.add_routes(routes)
app = web.Application()
app.add_subapp('/api/v1', api)
setup_aiojobs(app, limit=5000, pending_limit=5000)
return app
def _get_sentry_integrations() -> List[object]:
"""Get integrations for Sentry based on installed packages."""
integrations = []
try:
import flask
except ImportError:
pass
else:
try:
from sentry_sdk.integrations.flask import FlaskIntegration
except ImportError as exc:
_LOGGER.warning("Cannot import Sentry Flask integration: %s",
str(exc))
else:
integrations.append(FlaskIntegration())
_LOGGER.debug("Flask integration for Sentry enabled")
try:
import sqlalchemy
except ImportError:
pass
else:
try:
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
except ImportError as exc:
_LOGGER.warning("Cannot import Sentry SQLAlchemy integration: %s",
str(exc))
else:
integrations.append(SqlalchemyIntegration())
_LOGGER.debug("SQLAlchemy integration for Sentry enabled")
if sys.version_info >= (3, 7):
# Available only for python 3.7+
try:
import aiohttp
except ImportError:
pass
else:
try:
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
except ImportError as exc:
_LOGGER.warning("Cannot import Sentry AIOHTTP integration: %s",
str(exc))
else:
integrations.append(AioHttpIntegration())
_LOGGER.debug("AIOHTTP integration for Sentry enabled")
return integrations