Python BottleIntegration Examples

Example #1

 def __initialize_sentry_log():
     sentry_logging = LoggingIntegration(
         level=logging.INFO,  # Capture info and above as breadcrumbs
         event_level=logging.ERROR  # Send errors as events
     )
     sentry_sdk.init(dsn=sentry_dsn,
                     integrations=[BottleIntegration(), sentry_logging])

Example #2

File: server.py Project: daniltarasov/D2_homework

from sentry_sdk.integrations.bottle import BottleIntegration
from sentry_sdk.integrations.logging import LoggingIntegration, ignore_logger

# Получаем адрес из переменной окружения (должна быть прописана в хероку), а если её нет, то из файла env.py
SENTRY_DSN = os.environ.get("SENTRY_DSN")
if not SENTRY_DSN:
    from env import SENTRY_DSN

# Настройка, позволяющая отправлять в Sentry не только ошибки, но и логи любого уровня.
# Выбран уровень INFO
sentry_logging = LoggingIntegration(
    level=logging.INFO,
    event_level=logging.INFO
)

sentry_sdk.init(dsn=SENTRY_DSN, integrations=[BottleIntegration(), sentry_logging])

# Игнорируем сообщения от gunicorn-овских логгеров
ignore_logger("gunicorn.error")
ignore_logger("gunicorn.access")

formatter = logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s")
logger = logging.getLogger("new_logger")
logger.setLevel(logging.DEBUG)

stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
stream_handler.setLevel(logging.DEBUG)

logger.addHandler(stream_handler)
app = Bottle()

Example #3

File: logger.py Project: roshak7/d2_homework

import os
from bottle import Bottle, request  
import sentry_sdk  
from sentry_sdk.integrations.bottle import BottleIntegration  
  
sentry_sdk.init(dsn=os.environ.get("SENTRY_DSN"), integrations=[BottleIntegration()])  
  
app = Bottle()  


@app.route('/success') 
def success():
    return    

@app.route('/fail') 
def fail():    
    raise RuntimeError("There is an error!")
    
app.run(host='localhost', port=8080)

Example #4

File: server.py Project: H4RP3R/SF_D2.10

import sentry_sdk

from bottle import Bottle, run
from sentry_sdk.integrations.bottle import BottleIntegration

import os

# read environment variable
DSN = os.environ['DSN']

sentry_sdk.init(dsn=DSN,
                integrations=[BottleIntegration(transaction_style='url')])

app = Bottle()


@app.route('/')
def index():
    return 'Howdy!'


@app.route('/success')
def success():
    return 'Everything is alright'


@app.route('/fail')
def fail():
    raise RuntimeError('A terrible error has occurred')
    return

Example #5

File: server.py Project: tkatska/D2.10

import os
import sentry_sdk
from bottle import Bottle, request
from sentry_sdk.integrations.bottle import BottleIntegration

sentry_sdk.init(dsn="Ваш DSN", integrations=[BottleIntegration()])

app = Bottle()


@app.route("/")
def index():
    return "Paths: /success, /fail"


@app.route("/success")
def success():
    return "Success"


@app.route("/fail")
def fail():
    raise RuntimeError("There is an error!")
    return


if os.environ.get("APP_LOCATION") == "heroku":
    app.run(
        host="0.0.0.0",
        port=int(os.environ.get("PORT", 5000)),
        server="gunicorn",

Example #6

import sentry_sdk

from bottle import route, run
from sentry_sdk.integrations.bottle import BottleIntegration

my_SENTRY_DSN = "https://[email protected]/5219066"

if "SENTRY_DSN" in globals():
    SENTRY_DSN = os.environ["SENTRY_DSN"]
else:
    from env import SENTRY_DSN

if len(SENTRY_DSN) < 11:
    SENTRY_DSN = my_SENTRY_DSN

sentry_sdk.init(dsn=SENTRY_DSN, integrations=[BottleIntegration()])


@route('/')
def init_way():
    return """<h1> It's OK.</h1> 
    <h2> You should try:  /success   and   /fail</h2>"""


@route('/fail')
def fail():
    raise RuntimeError("It's an error!!")


@route('/success')
def success():

Example #7

File: settings.py Project: TeresaZhu08/Ass1

EMAIL_HOST = 'localhost'
EMAIL_PORT = 1025

INTERNAL_IPS = [
    '127.0.0.1',
]

sentry_sdk.init(
    dsn=
    "https://[email protected]/5258529",
    integrations=[
        DjangoIntegration(),
        CeleryIntegration(),
        RedisIntegration(),
        BottleIntegration(),
    ],

    # If you wish to associate users to errors (assuming you are using
    # django.contrib.auth) you may enable sending PII data.
    send_default_pii=True)

app = Bottle()

RAVEN_CONFIG = {
    'environment':
    'production',  # optional but very useful
    'release':
    raven.fetch_git_sha(os.path.dirname(
        os.pardir)),  # optional but very useful
    'dsn':

Example #8

import sentry_sdk
import os
from bottle import route, run, error
from sentry_sdk.integrations.bottle import BottleIntegration
from sentry_sdk import capture_exception, capture_message
from my_dsn import dsn

sentry_sdk.init(dsn=dsn, integrations=[BottleIntegration()])


@route("/")
def default_page():
    pass


@route("/success")
def success():
    pass


@route("/fail")
def fail():
    capture_message("something error")
    return RuntimeError


@route("/raise")
def crash():
    raise Exception

Example #9

import os
import sentry_sdk

from bottle import Bottle, run, HTTPResponse
from sentry_sdk.integrations.bottle import BottleIntegration

## Введите вашу ссылку dsn
sentry_sdk.init(dsn="ENTER_YOUR_DSN", integrations=[BottleIntegration()])

app = Bottle()


@app.route('/success')
def index():
    return HTTPResponse(status=200, body="Успешный запрос")


@app.route('/')
def index():
    return HTTPResponse(status=200, body="Вы на главной странице.")


@app.route('/fail')
def index():
    raise RuntimeError("Oppps,Server error!")
    return HTTPResponse(status=500, body="Fail request")


if os.environ.get("APP_LOCATION") == "heroku":
    app.run(
        host="0.0.0.0",

Example #10

from bottle import run, route, view
import os
import random
import logging

import sentry_sdk
from sentry_sdk.integrations.bottle import BottleIntegration

sentry_sdk.init(dsn=os.environ.get('DSN'), integrations=[BottleIntegration()])

formatter = logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s")
logger = logging.getLogger("my-logger")
logger.setLevel(logging.DEBUG)

stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
stream_handler.setLevel(logging.DEBUG)

logger.addHandler(stream_handler)


@route('/')
@view('base')
def index():
    pass


@route("/success")
def success():
    print('OK')
    return 'OK'

Example #11

File: d2_9.py Project: evgeniyli9407/module_d2

import os
from bottle import Bottle, request
import sentry_sdk
from sentry_sdk.integrations.bottle import BottleIntegration

sentry_sdk.init(dsn=os.environ.get("https://[email protected]/1858658"), integrations=[BottleIntegration()])

app = Bottle()


@app.route('/success')
def success():
    return ('Ошибки нет, ты перешёл в success')


@app.route('/fail')
def fail():
    raise RuntimeError("Ошибка!")


app.run(host='localhost', port=8080)

Example #12

from bottle import Bottle, response
from sentry_sdk.integrations.bottle import BottleIntegration
import sentry_sdk
import os
from dotenv import load_dotenv

load_dotenv()
# интеграция с Sentry
sentry_sdk.init(dsn=os.environ['SENTRY'], integrations=[BottleIntegration()])

app = Bottle()


@app.route('/')
def index():
    # определение где запущен сервер, локально или на Heroku
    if os.environ.get('APP_LOCATION') == 'heroku':
        host = "https://bsbottle.herokuapp.com"
        port = ""
    else:
        host = "localhost"
        port = "8080"
    href1 = f"http://{host}:{port}/success" if port else f"{host}/success"
    href2 = f"http://{host}:{port}/fail" if port else f"{host}/fail"
    html = f"""
        <!DOCTYPE html>
        <html lang="ru">
        <head>
            <meta charset="UTF-8">
            <title>Heroku test bottle server</title>
        </head>

Example #13

def main():
    parser = get_arg_parser()
    args = parser.parse_args()

    # setup logging
    logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING)
    logger = logging.getLogger("foris")

    if args.log_file:
        file_handler = logging.FileHandler(args.log_file)
        logging.getLogger().addHandler(file_handler)

    logger.debug("Version %s", __version__)

    # try to include sentry (if installed)
    try:
        import sentry_sdk
        from sentry_sdk.integrations.bottle import BottleIntegration

        try:
            dsn = os.environ["SENTRY_DSN"]
            sentry_sdk.init(dsn=dsn, integrations=[BottleIntegration()])
            current_state.set_sentry(True)
        except (KeyError, sentry_sdk.utils.BadDsn):
            pass
    except ImportError:
        pass

    # set backend
    if args.message_bus in ["ubus", "unix-socket"]:
        current_state.set_backend(Backend(args.message_bus, path=args.bus_socket))
    elif args.message_bus == "mqtt":
        current_state.set_backend(
            Backend(
                args.message_bus,
                host=args.mqtt_host,
                port=args.mqtt_port,
                credentials=args.mqtt_passwd_file,
                controller_id=args.mqtt_controller_id,
            )
        )

    # update websocket
    current_state.set_websocket(args.ws_port, args.ws_path, args.wss_port, args.wss_path)
    # set assets path
    current_state.set_assets_path(args.assets)

    if args.app == "config":
        from foris.config_app import prepare_config_app

        main_app = prepare_config_app(args)

    if args.routes:
        # routes should be printed and we can safely exit
        return True

    # run the right server
    if args.server == "wsgiref":
        bottle.run(app=main_app, host=args.host, port=args.port, debug=args.debug)
    elif args.server == "flup":
        # bindAddress is None - FCGI process must be spawned by the server
        bottle.run(app=main_app, server="flup", debug=args.debug, bindAddress=None)
    elif args.server == "cgi":
        bottle.run(app=main_app, server="cgi", debug=args.debug)

Example #14

#Импортируем sentry и bottle
import sentry_sdk
import os
from bottle import Bottle, request, route, run, response, HTTPResponse
from sentry_sdk.integrations.bottle import BottleIntegration

#Инициализируем sentry с нашими данными
sentry_sdk.init(
    dsn="https://тутможетбытьваш[email protected]/5540996",
    integrations=[BottleIntegration()])

app = Bottle()


#Создаём нужные маршруты
#Основная страница с выбором маршрута
@app.route('/')
def index():
    htmlCode = """
    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>D2.10_HW Mazalov.N.A </title>
    </head>
    <body>
        <h1>Ниже выберете нужный вариант</h1>
        <h2><a href='https://polar-forest-03681.herokuapp.com/success'>Соединение установлено</a></h2>
        <h2><a href='https://polar-forest-03681.herokuapp.com/fail'>Ошибка сервера</a></h2>
    </body>

Example #15

from bottle import Bottle, request
import sentry_sdk
from sentry_sdk.integrations.bottle import BottleIntegration

sentry_sdk.init(dsn="Enter your SDN", integrations=[BottleIntegration()])

app = Bottle()


@app.route("/succss")
def succss():

    return


@app.route("/fail")
def fail():
    raise RuntimeError("There is an error")


app.run(host="localhost", port=8080)

Example #16

from raven.base import Raven
from sentry_sdk import init, capture_message, capture_exception
from sentry_sdk.integrations.bottle import BottleIntegration

import logging
from sentry_sdk.integrations.logging import LoggingIntegration

# All of this is already happening by default!
sentry_logging = LoggingIntegration(
    level=logging.INFO,        # Capture info and above as breadcrumbs
    event_level=logging.ERROR  # Send errors as events
)


sentry_client = init(dsn='https://[email protected]/1816701',
    integrations=[BottleIntegration(),sentry_logging])





capture_message("Hello World")  # Will create an event.

capture_exception(Exception("This is an example of an error message."))

Example #17

File: D2.9.py Project: BlackDow10/D2.9_shaev

import os
import logging  
from bottle import Bottle, request, HTTPError, run
import sentry_sdk
from sentry_sdk.integrations.bottle import BottleIntegration
sentry_sdk.init("https://[email protected]/1797787", integrations=[BottleIntegration()])


app = Bottle()

@app.route('/success')  
def index():  
   
    return  

@app.route('/fail')  
def fail():  
    raise RuntimeError("There is an error!")
   
    
  
  
if os.environ.get("APP_LOCATION") == "heroku":
    app.run(
        host="0.0.0.0",
        port=int(os.environ.get("PORT", 5000)),
        server="gunicorn",
        workers=3,
    )
else:
    app.run(host="localhost", port=8080, debug=True)