예제 #1
0
 def init_rollbar():
     rollbar.init(cfg["rollbar"]["token"],
                  cfg["rollbar"]["environment"],
                  root=os.path.dirname(os.path.realpath(__file__)),
                  allow_logging_basic_config=False)
     got_request_exception.connect(rollbar.contrib.flask.report_exception,
                                   app)
예제 #2
0
 def init_rollbar():
     rollbar.init(TOKEN,
                  'flasktest',
                  root=os.path.dirname(os.path.realpath(__file__)),
                  allow_logging_basic_config=True)
     got_request_exception.connect(rollbar.contrib.flask.report_exception,
                                   app)
예제 #3
0
def _connect_signals():
    rs_counter = Counter("web_request_started", "HTTP requests received")
    request_started.connect(lambda s, *a, **e: rs_counter.inc(), weak=False)
    rf_counter = Counter("web_request_finished", "HTTP requests successfully handled")
    request_finished.connect(lambda s, *a, **e: rf_counter.inc(), weak=False)
    re_counter = Counter("web_request_exception", "Failed HTTP requests")
    got_request_exception.connect(lambda s, *a, **e: re_counter.inc(), weak=False)
예제 #4
0
def set_up_rollbar():
    class CustomRequest(Request):
        @property
        def rollbar_person(self):
            if g.user:
                user = g.user

                return {
                    'id': user.id,
                    'username': user.get_username(),
                    'email': user.email
                }

    rollbar.init(
        app.config['ROLLBAR_ACCESS_TOKEN'],
        app.config['ROLLBAR_ENVIRONMENT'],
        root=app.config['ROLLBAR_ROOT'],
        handler='blocking',
        allow_logging_basic_config=False,
        timeout=5
    )

    got_request_exception.connect(report_exception, app)

    app.request_class = CustomRequest
예제 #5
0
def main(args=None):
    defaultdb = get_default_dbconfig()

    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--db", default=defaultdb)
    parser.add_argument("-d", "--debug", action="store_true", default=False)
    parser.add_argument("--pdb", action="store_true", default=False)
    parser.add_argument("-H",
                        "--host",
                        default=os.environ.get("CURIELOGSERVER_HOST",
                                               "127.0.0.1"))
    parser.add_argument("-p",
                        "--port",
                        type=int,
                        default=int(
                            os.environ.get("CURIELOGSERVER_PORT", "5000")))

    options = parser.parse_args(args)

    app.config['postgreSQL_pool'] = psycopg2.pool.ThreadedConnectionPool(
        1, 20, options.db)

    if options.pdb:
        got_request_exception.connect(drop_into_pdb)

    app.run(debug=options.debug, host=options.host, port=options.port)
예제 #6
0
def _conf_logging_errors(app):
    
    def log_exception(sender, exception, **extra):
        sender.logger.error(str(exception))
        
    from flask import got_request_exception
    got_request_exception.connect(log_exception, app)        
예제 #7
0
def create_api(app):
    api = Api(app, catch_all_404s=True, errors=errors)
    api.representations['application/xml'] = output_xml
    got_request_exception.connect(log_exception, app)

    api.add_resource(Recipes, '/recipes', endpoint='recipes')
    api.add_resource(Recipes, '/recipes/<int:recipe_id>', endpoint='recipe')
예제 #8
0
def create_app():
    """create flask-sports app"""

    app = Flask(__name__)

    app.secret_key = '4A8BF09E6732FDC682988A8SYZ666AB7CF53176D08631E'

    config = load_config(CONFIGS['2'])  # 选择环境

    # load logger
    setup_log(config)

    # load config
    app.config.from_object(config)

    # register blueprint
    # app.register_blueprint(test)

    celery_app.init_app(app)  # 注册celery应用
    redis_app.init_app(app)  # 注册redis应用
    sms.init_app(app)  # 注册阿里云短信服务
    signal.init_app(app)  # 注册发送验证码信号
    db.init_app(app)  # 注册mongodb实例
    oss.init_app(app)  # 注册OSS服务

    with app.app_context():
        # 手动推送上下文
        # get_user_model(app) # 注册用户模型表
        pass

    got_request_exception.connect(log_exception, app)  # 记录请求的异常

    return app
예제 #9
0
파일: app.py 프로젝트: Nefelly/nl_to_uml
 def setup_signals(cls, app):
     app.before_first_request(before_first_request_handler)
     request_started.connect(request_started_handler, app)
     app.before_request(before_request_handler)
     got_request_exception.connect(got_request_exception_handler, app)
     request_finished.connect(request_finished_handler, app)
     app.teardown_request(teardown_request_handler)
예제 #10
0
    def init_app(self, app):
        """
        Initializes the extension with the given app, registers the
        built-in views with an own blueprint and hooks up our signal
        callbacks.
        """
        # If no version path was provided in the init of the Dockerflow
        # class we'll use the parent directory of the app root path.
        if self.version_path is None:
            self.version_path = os.path.dirname(app.root_path)

        for view in (
            ('/__version__', 'version', self._version_view),
            ('/__heartbeat__', 'heartbeat', self._heartbeat_view),
            ('/__lbheartbeat__', 'lbheartbeat', self._lbheartbeat_view),
        ):
            self._blueprint.add_url_rule(*view)
        self._blueprint.before_app_request(self._before_request)
        self._blueprint.after_app_request(self._after_request)
        self._blueprint.app_errorhandler(HeartbeatFailure)(
            self._heartbeat_exception_handler)
        app.register_blueprint(self._blueprint)
        got_request_exception.connect(self._got_request_exception, sender=app)

        if not hasattr(app, 'extensions'):  # pragma: nocover
            app.extensions = {}
        app.extensions['dockerflow'] = self
예제 #11
0
def create_app(name=__name__, config=None, skip_defaults=False):
    """
    app factory
    If config is not passed, env is inspected for 'APP_CONFIG'. If not present,
    the base defaults from settings.BaseConfig apply (local server, etc)
    """

    app = Flask(name)
    if not config:
        log.warning("Using default config")
        config = Config()
    app.config.from_object(config)

    blueprint = Blueprint('api', __name__, url_prefix='/api')

    api.add_namespace(healthcheck_namespace)
    api.add_namespace(activities_namespace)
    api.add_namespace(blobs_namespace)
    api.add_namespace(items_namespace)
    init_app(app)
    api.init_app(blueprint)

    blueprint.before_request(setup_db)
    app.register_blueprint(blueprint)

    got_request_exception.connect(drop_into_pdb)
    try:
        if '-echo' in str(subprocess.check_output("stty", shell=True)):
            log.debug("Re-enabling echo w/ stty")
            subprocess.check_call("stty echo", shell=True)
    except subprocess.CalledProcessError:
        pass

    return app
예제 #12
0
파일: flask.py 프로젝트: vdedyukhin/pybrake
def init_app(app):
    if "pybrake" in app.extensions:
        raise ValueError("pybrake is already injected")
    if "PYBRAKE" not in app.config:
        raise ValueError("app.config['PYBRAKE'] is not defined")

    notifier = Notifier(**app.config["PYBRAKE"])
    apm_disabled = notifier._apm_disabled

    notifier.add_filter(request_filter)

    app.extensions["pybrake"] = notifier
    got_request_exception.connect(_handle_exception, sender=app)

    if not apm_disabled:
        before_render_template.connect(_before_render_template, sender=app)
        template_rendered.connect(_template_rendered, sender=app)

        app.before_request(_before_request(notifier))
        app.after_request(_after_request(notifier))

        if _sqla_available:
            _sqla_instrument(app)

    return app
예제 #13
0
def configure_app(app):
    log_msg_format = app.config['API_LOG_MSG_FORMAT']
    log_date_format = app.config['API_LOG_DATE_FORMAT']

    sqla_logger = logging.getLogger('sqlalchemy')
    pool_logger = logging.getLogger('sqlalchemy.pool')

    # Set the message formatter for the default log handler
    current_handlers = app.logger.handlers
    default_handler = current_handlers[0] if current_handlers else None
    if default_handler:
        # A newline is included before the log message to visually separate them better
        default_handler.setFormatter(logging.Formatter("\n" + log_msg_format, datefmt=log_date_format))
        pool_logger.addHandler(default_handler)

    # Setup the log handlers if not testing
    if not app.testing:
        # Rotating file handler
        file_handler = handlers.RotatingFileHandler(
            app.config['API_LOG_FILE_PATH'],
            mode='a',
            maxBytes=1 * 1024 * 1024,
            backupCount=10)
        file_handler.setLevel(logging.INFO)
        file_handler.setFormatter(logging.Formatter(log_msg_format, datefmt=log_date_format))

        # Add handlers to loggers
        loggers = [app.logger, sqla_logger]
        for logger in loggers:
            logger.addHandler(file_handler)

    # Set the log level
    if 'LOG_LEVEL' in app.config:
        # Log at the level specified in the app config
        app.logger.setLevel(app.config['LOG_LEVEL'])
    else:
        # Log at the DEBUG level when testing/debugging, otherwise log INFO and above
        if app.debug or app.testing:
            app.logger.setLevel(logging.DEBUG)
        else:
            app.logger.setLevel(logging.INFO)

    # Configure connection pool debug logging
    if app.config.get('POOL_DEBUG_LOGGING'):
        pool_logger.setLevel(logging.DEBUG)

    # Include this extra information in all log messages (lambda functions get executed at log time)
    if app.config.get('API_LOG_VERBOSE_DEV_MESSAGES', False):
        extra_info = lu.ExtraInfo()
        extra_info['ip'] = lambda: has_request_context() and ah.get_remote_addr() or None
        extra_info['uid'] = lambda: str(g.user.id).upper() if hasattr(g, 'user') and g.user.id else None
        extra_info['ua'] = lambda: has_request_context() and ah.get_user_agent_summary() or None
        extra_info['url'] = lambda: has_request_context() and request.url or None

        app._logger = lu.ExtraInfoLogger(app.logger, extra_info)

    # Connect the exception logging functions to the `got_request_exception` signal
    got_request_exception.connect(lu.log_api_exception, app)
    got_request_exception.connect(lu.log_api_exception_to_browser_console, app)
 def setUp(self):
     self.exception_msg = "There is a nasty gremlin in this system"
     self.exception = RequestException(self.exception_msg)
     self.test_app = AirbrakeTestApp(self.exception)
     self.client = self.test_app.app.test_client()
     got_request_exception.connect(
         self.test_app.ab.process_exception, sender=self.test_app.app
     )
예제 #15
0
def init_rollbar():
    rollbar.init(
        ROLLBAR_KEY,
        ROLLBAR_APP,
        root=os.path.dirname(os.path.realpath(__file__)),
        allow_logging_basic_config=False)
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
    rollbar.report_message('App booted', 'warning')
예제 #16
0
def init_rollbar():
    """init rollbar module"""
    rollbar.init('6b773c84e86041798a513ba8ef73bb74',
                 'petchat-flask',
                 root=os.path.dirname(os.path.realpath(__file__)),
                 allow_logging_basic_config=False)

    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #17
0
파일: app.py 프로젝트: iluddy/flock
 def init_rollbar():
     rollbar.init(
         cfg["rollbar"]["token"],
         cfg["rollbar"]["environment"],
         root=os.path.dirname(os.path.realpath(__file__)),
         allow_logging_basic_config=False
     )
     got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #18
0
def init_rollbar(app):
    from flask import got_request_exception
    rollbar.init(TOKEN, 'flasktest',
                 root=os.path.dirname(os.path.realpath(__file__)),
                 allow_logging_basic_config=True,
                 capture_email=True,
                 capture_username=True)
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
def full_dispatch_request_with_instana(wrapped, instance, argv, kwargs):

    got_request_exception.connect(log_exception_with_signoz, instance)
    request_started.connect(request_started_with_signoz, instance)
    request_finished.connect(request_finished_with_signoz, instance)
    instance.teardown_request(teardown_request_with_signoz)

    return wrapped(*argv, **kwargs)
예제 #20
0
def _conf_logging_errors(app):
    def log_exception(sender, exception, **extra):
        print("log_exception.exception : ", exception)
        print("log_exception;extra : ", extra)
        sender.logger.error(str(exception))

    from flask import got_request_exception
    got_request_exception.connect(log_exception, app)
예제 #21
0
def full_dispatch_request_with_instana(wrapped, instance, argv, kwargs):
    if not hasattr(instance, '_stan_wuz_here'):
        logger.debug("Applying flask before/after instrumentation funcs")
        setattr(instance, "_stan_wuz_here", True)
        got_request_exception.connect(log_exception_with_instana, instance)
        request_started.connect(request_started_with_instana, instance)
        request_finished.connect(request_finished_with_instana, instance)
    return wrapped(*argv, **kwargs)
예제 #22
0
def setup_rollbar():
    if ROLLBAR_ACCESS_TOKEN:
        rollbar.init(ROLLBAR_ACCESS_TOKEN,
                     BRICKY_ENV,
                     root=os.path.dirname(os.path.realpath(__file__)),
                     allow_logging_basic_config=False)
        got_request_exception.connect(rollbar.contrib.flask.report_exception,
                                      app)
예제 #23
0
    def init_rollbar():
        """init rollbar module"""
        if app.config['ENV'] in ('production',) and app.config['ROLLBAR_API']:
            rollbar.init(access_token=app.config['ROLLBAR_API'],
                         environment=app.config['ENV'],
                         root=app.config['APP_DIR'],
                         allow_logging_basic_config=False)

            got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #24
0
파일: index.py 프로젝트: daveweber/FlaskBar
def init_rollbar():
    """init rollbar module"""
    rollbar.init(
        'c6393fb20bf5493bbd0cc0d667ccc863',
        'local',
        root=os.path.dirname(os.path.realpath(__file__)),
        allow_logging_basic_config=False)

    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #25
0
    def init_rollbar(self, app):
        rollbar.init(
            app.config['ROLLBAR_TOKEN'],
            app.config['FLASK_ENV'],
            root=os.path.dirname(os.path.realpath(__file__)),
            allow_logging_basic_config=False)

        got_request_exception.connect(
            rollbar.contrib.flask.report_exception, app)
예제 #26
0
def register_rollbar(app):
    rollbar.init(
        access_token=app.config['ROLLBAR_ACCESS_TOKEN'],
        environment=app.config['ROLLBAR_ENV_NAME'],
        root=os.path.dirname(os.path.realpath(__file__)),
        allow_logging_basic_config=False,
    )

    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #27
0
파일: h2o.py 프로젝트: anxuae/pih2o
    def __init__(self, config):
        self._thread = None
        self._stop = threading.Event()
        self.config = config

        LOGGER.debug("Initializing flask instance")
        self.flask_app = flask.Flask(pih2o.__name__)
        self.flask_app.config.from_object('pih2o.config')
        got_request_exception.connect(self.log_exception, self.flask_app)

        @self.flask_app.route('/pih2o')
        def say_hello():
            return flask.jsonify({
                "name": pih2o.__name__,
                "version": pih2o.__version__,
                "running": self.is_running()
            })

        LOGGER.debug("Initializing the database for measurements")
        models.db.init_app(self.flask_app)
        with self.flask_app.app_context():
            models.db.create_all()

        LOGGER.debug("Initializing the RESTful API")
        self.api = Api(self.flask_app, catch_all_404s=True)

        root = '/pih2o/api/v1'
        self.api.add_resource(ApiConfig,
                              root + '/config',
                              root + '/config/<string:section>',
                              root + '/config/<string:section>/<string:key>',
                              endpoint='config',
                              resource_class_args=(config, ))
        self.api.add_resource(ApiPump,
                              root + '/pump',
                              root + '/pump/<int:duration>',
                              endpoint='pump',
                              resource_class_args=(self, ))
        self.api.add_resource(ApiSensors,
                              root + '/sensors',
                              root + '/sensors/<int:pin>',
                              endpoint='sensors',
                              resource_class_args=(self, ))
        self.api.add_resource(ApiMeasurements,
                              root + '/measurements',
                              endpoint='measurements',
                              resource_class_args=(models.db, ))

        # The HW connection of the controls
        GPIO.setmode(GPIO.BOARD)  # GPIO in physical pins mode
        self.pump = None
        self.sensors = []
        self._pump_timer = None

        self.init_controls()

        atexit.register(self.shutdown_daemon)
예제 #28
0
def init_rollbar():
    if not app.debug:
        if os.environ.get('ROLLBAR_ACCESS_TOKEN'):
            rollbar.init(os.environ.get('ROLLBAR_ACCESS_TOKEN'),
                         'python-blog-dev',
                         root=os.path.dirname(os.path.realpath(__file__)),
                         allow_logging_basic_config=False)
            got_request_exception.connect(
                rollbar.contrib.flask.report_exception, app)
            rollbar.report_message('Rollbar configured for python-blog')
예제 #29
0
def init_rollbar():
    rollbar.init(access_token='8026b336e7e4475482765f8b119d4049',
                 environment='flask_test',
                 root=os.path.dirname(os.path.realpath(__file__)),
                 allow_logging_basics_config=False,
                 code_version=get_git_sha())
    rollbar.report_message('Rollbar initialized succesfully', level='debug')

    got_request_exception.connect(rb_flask.report_exception, app)
    got_request_exception.connect(rb_flask.report_exception, bp_error_handler)
예제 #30
0
def init_rollbar():
    if not hasattr(config, 'TESTMODE'):
        env = 'production'
        if request.remote_addr == '127.0.0.1':
            env = 'development'
        rollbar.init(config.ROLLBAR_TOKEN, environment=env)

        # send exceptions from `app` to rollbar, using flask's signal system.
        got_request_exception.connect(rollbar.contrib.flask.report_exception,
                                      app)
예제 #31
0
def init_rollbar():
    """init rollbar module"""
    rollbar.init(
        app.config["ROLLBAR_TOKEN"],
        app.config["ENV"],
        root=os.path.dirname(os.path.realpath(__file__)),
        allow_logging_basic_config=False,
    )

    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #32
0
파일: ext.py 프로젝트: zhoudaqing/huskar
    def init_app(self, app):
        assert self.STATE_KEY not in app.extensions
        app.extensions[self.STATE_KEY] = HealthTester(self.configs)
        app.before_request(self.before_request)
        request_finished.connect(self.handle_request_finished, app)
        request_tearing_down.connect(self.handle_request_tearing_down, app)
        got_request_exception.connect(self.handle_got_request_exception, app)

        from huskar_api.models.signals import session_load_user_failed
        session_load_user_failed.connect(self.handle_load_user_failed)
예제 #33
0
def init_rollbar():
    """Initialize Rollbar."""
    rollbar.init(
        os.environ['ROLLBAR_ACCESS_TOKEN'],
        os.environ['STAGE'],
        # Flask already sets up logging.
        allow_logging_basic_config=False)

    # Send exceptions from `app` to Rollbar, using Flask's signal system.
    got_request_exception.connect(report_exception, app)
예제 #34
0
    def init_app(self, app):
        werkzeug = logging.getLogger("werkzeug")
        werkzeug.disabled = True

        formatter = logging.Formatter("[%(asctime)s.%(msecs)03d] (%(levelname)s) %(message)s","%m-%d-%Y %H:%M:%S")
        default_handler.setFormatter(formatter)
        app.logger.setLevel(app.config['LOG_LEVEL'])

        app.after_request(self.cleanup)
        got_request_exception.connect(self.bailout, app)
예제 #35
0
def main():
    app = Flask('rj_worker')
    app.debug = True
    api = Api(app)
    api.add_resource(Run, '/run')

    app.logger.setLevel(logging.DEBUG)
    got_request_exception.connect(log_exception, app)
    app.logger.info('Starting RJ Worker')

    app.run(host='0.0.0.0', port=5000, use_reloader=False)
예제 #36
0
def init_rollbar():
    """init rollbar module"""
    rollbar.init(
        config.ROLLBAR_KEY,
        config.ROLLBAR_ENV,
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        allow_logging_basic_config=False
    )
    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(report_exception, current_app._get_current_object())
예제 #37
0
def setup_app(app):
    #setup syslog
    app.logger.addFilter(app_logging.ContextFilter())
    syslog_handler = app_logging.get_syslog_handler()
    if syslog_handler:
        app.logger.addHandler(syslog_handler)

        #send application error exception message to log
        def log_exception(sender, exception, **extra):
            sender.logger.error(exception)
        got_request_exception.connect(log_exception, app)
예제 #38
0
def create_app(config_pyfile=None):
    """
    Create a Flask application using the app factory pattern.

    :param settings_override: Override settings
    :return: Flask app
    """
    # app = Flask(__name__, instance_relative_config=True)
    app = Flask(__name__)

    # add global CORS support
    # https://flask-cors.readthedocs.io/en/latest/
    CORS(app)
    # only support config/settings files for config
    # app.config.from_object('config.settings')
    app.config.from_object(config_pyfile)
    # app.config.from_pyfile('settings.py', silent=True)
    # app.config.from_pyfile(config_pyfile, silent=True)
    # app.config.from_pyfile(config_pyfile, silent=False)

    # if settings_override:
    #    app.config.update(settings_override)

    # now log config being used
    app.logger.info("Debug status is: " + str(app.config["DEBUG"]))
    app.logger.info("Testing status is: " + str(app.config["TESTING"]))
    app.logger.info("Development status is: " + str(app.config["DEVELOPMENT"]))
    app.logger.info("Server Name is: " + str(app.config["SERVER_NAME"]))

    # @app.before_first_request
    # def init_rollbar():
    # init rollbar module
    rollbar.init(
        # access token for the app
        str(app.config["ROLLBAR_TOKEN"]),
        # environment name
        str(app.config["ROLLBAR_ENVIRONMENT"]),
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        # flask already sets up logging
        allow_logging_basic_config=False,
    )

    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
    rollbar.report_message("Starting app for flask-api2", "info")

    app.register_blueprint(page)
    app.register_blueprint(raw)
    app.register_blueprint(search)
    app.register_blueprint(api)
    extensions(app)

    return app
예제 #39
0
        def init_rollbar():

            if self._enabled:

                # Example taken from https://github.com/rollbar/rollbar-flask-example/blob/master/hello.py
                self._rb = init(
                    self._server_key,
                    self._environment,
                    root=os.path.dirname(os.path.realpath(__file__)),  # server root directory, makes tracebacks prettier
                    allow_logging_basic_config=False)  # flask already sets up logging

                got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #40
0
def init_flask_signals(_app):
    from fw.db.sql_base import db as sqldb

    def finish_db_transaction(sender, **extra):
        sqldb.session.commit()

    def rollback(sender, **extra):
        sqldb.session.rollback()

    from flask import request_finished, got_request_exception
    request_finished.connect(finish_db_transaction, _app)
    got_request_exception.connect(rollback, _app)
예제 #41
0
def init_rollbar():
    token = app.config.get('ROLLBAR_ACCESS_TOKEN')
    if token is None:
        return

    rollbar.init(
        token, 'production',
        root=os.path.dirname(os.path.realpath(__file__)),
        allow_logging_basic_config=False
    )

    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #42
0
def init_rollbar():
    if app.config['ROLLBAR_TOKEN']:
        rollbar.init(
            app.config['ROLLBAR_TOKEN'],
            app.config['ENVIRONMENT'],
            # server root directory, makes tracebacks prettier
            root=os.path.dirname(os.path.realpath(__file__)),
            # flask already sets up logger
            allow_logger_basic_config=False)
        logger.debug("Rollbar intiated")

        # send exceptions from `app` to rollbar, using flask's signal system.
        got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #43
0
파일: webapp.py 프로젝트: sibson/ghinbox
def init_rollbar():
    rollbar.init(
        # access token for the demo app: https://rollbar.com/demo
        app.config['ROLLBAR_ACCESS_TOKEN'],
        # environment name
        'production',
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        # flask already sets up logging
        allow_logging_basic_config=False)

    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #44
0
def init_rollbar():
    """init rollbar module"""
    rollbar.init(
        # access token for the demo app: https://rollbar.com/demo
        '4007dbacf03f426ab291c36da97da1e6',
        # environment name
        'production',
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        # flask already sets up logging
        allow_logging_basic_config=False)

    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #45
0
    def __init__(self, app):
        self.app = app

        if 'BLUEOX_HOST' in app.config:
            self.blueox_host = app.config['BLUEOX_HOST']
            if self.blueox_host:
                blueox.default_configure(self.blueox_host)
        else:
            blueox.default_configure()

        self.app.before_request(self.before_request)
        self.app.after_request(self.after_request)

        got_request_exception.connect(self.handle_exception, self.app)
예제 #46
0
    def init_rollbar():
        """init rollbar module"""
        rollbar.init(
            os.environ['ROLLBAR_SERVER_TOKEN'],
            # environment name
            os.environ['ENV'],
            # server root directory, makes tracebacks prettier
            root=os.path.dirname(os.path.realpath(__file__)),
            # flask already sets up logging
            allow_logging_basic_config=False)

        # send exceptions from `app` to rollbar, using flask's signal system.
        got_request_exception.connect(
            rollbar.contrib.flask.report_exception, app)
예제 #47
0
파일: __init__.py 프로젝트: pychuang/ll-api
def init_rollbar():
    """init rollbar module"""
    rollbar.init(
        # access token for the demo app: https://rollbar.com/demo
        core.config.config["ROLLBAR_DASHB0ARD_KEY"],
        # environment name
        core.config.config["ROLLBAR_ENV"],
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        # flask already sets up logging
        allow_logging_basic_config=False)

    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #48
0
def init_rollbar():
    """init rollbar module"""
    rollbar.init(
        # access token for the demo app: https://rollbar.com/demo
        'fc316ac1f7404dc28af26d5baed1416c',
        # environment name
        'flasktest',
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        # flask already sets up logging
        allow_logging_basic_config=False)

    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #49
0
    def init_app(self, app):
        self.app = app
        app.extensions['rollbar'] = self
        ignored = [(exc, 'ignored') for exc in self.ignore_exc]
        rollbar.init(
            app.config['ROLLBAR_TOKEN'],
            environment=app.config.get('ROLLBAR_ENV', 'dev'),
            root=os.path.dirname(os.path.realpath(__file__)),
            allow_logging_basic_config=False,
            exception_level_filters=ignored,
            **self.init_kwargs
        )

        # send exceptions from `app` to rollbar using flask's signal system.
        got_request_exception.connect(report_exception)
예제 #50
0
파일: start.py 프로젝트: xqliu/visualsbest
def init_rollbar():
    """init rollbar module"""
    if config.DEBUG is not True:
        rollbar.init(
            # access token for the demo app: https://rollbar.com/demo
            '90a56a42d47d4343a45b1105338d47c8',
            # environment name
            'heroku_development',
            # server root directory, makes tracebacks prettier
            root=os.path.dirname(os.path.realpath(__file__)),
            # flask already sets up logging
            allow_logging_basic_config=False)

        # send exceptions from `app` to rollbar, using flask's signal system.
        got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
예제 #51
0
파일: helpers.py 프로젝트: bdeeney/crudite
def subscribe_logging_helpers(app):
    """
    Configure functions that log in response to Flask signals emitted by app.

    Flask signal            function invoked
    ------------            -------------------
    request_started         log_request
    template_rendered       log_template_rendered
    request_finished        log_response
    got_request_exception   log_exception

    """
    request_started.connect(log_request, app)
    template_rendered.connect(log_template_rendered, app)
    request_finished.connect(log_response, app)
    got_request_exception.connect(log_exception, app)
예제 #52
0
def init_rollbar():
    """Initialize rollbar module.

    It also allows person tracking.
    https://github.com/rollbar/rollbar-flask-example/blob/master/hello.py
    """
    rollbar.init(
        '2deae0df9d884836ab6eb7ea3057b992',
        # environment name
        'development',
        # server root directory, makes tracebacks prettier
        root=os.path.dirname(os.path.realpath(__file__)),
        # flask already sets up logging
        allow_logging_basic_config=False)

    # send exceptions from `app` to rollbar, using flask's signal system.
    got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
def init_app(app):
    if app.config.get('ROLLBAR_TOKEN') and not app.config.get('DEBUG', True):
        rollbar.init(
            # access token for the demo app: https://rollbar.com/demo
            app.config['ROLLBAR_TOKEN'],
            # environment name
            app.config['DM_ENVIRONMENT'],
            # server root directory, makes tracebacks prettier
            root=os.path.dirname(os.path.realpath(__file__)),
            # flask already sets up logging
            allow_logging_basic_config=False)

        # supplement base data collected by rollbar
        rollbar.BASE_DATA_HOOK = _hook

        # send exceptions from `app` to rollbar, using flask's signal system.
        got_request_exception.connect(report_exception, app)
예제 #54
0
    def init_rollbar():
        """init rollbar module"""
        rollbar.init(
            # access token
            os.environ.get('ROLLBAR_TOKEN', ''),
            # environment name
            os.environ.get('ROLLBAR_ENV', 'development'),
            # server root directory, makes tracebacks prettier
            root=os.path.dirname(os.path.realpath(__file__)),
            # flask already sets up logging
            allow_logging_basic_config=False,
            # Use HTTP as GAE does not allow the use of the SSL package
            endpoint='http://api.rollbar.com/api/1/')

        # send exceptions from `app` to rollbar, using flask's signal system.
        got_request_exception.connect(rollbar.contrib.flask.report_exception,
                                      app)
예제 #55
0
def setup_app(app):
    #setup syslog
    app.logger.addFilter(app_logging.ContextFilter())
    syslog_handler = app_logging.get_syslog_handler()
    if syslog_handler:
        app.logger.addHandler(syslog_handler)
        #send application error exception message to log
        def log_exception(sender, exception, **extra):
            sender.logger.error(exception)
        got_request_exception.connect(log_exception, app)
        #setup bugsnag
        bugsnag_api_key =  os.getenv('SS_SORAYA_RECO_BUGSNAG_API_KEY')
        if bugsnag_api_key:
            bugsnag.configure(
                api_key= bugsnag_api_key,
                project_root=os.path.abspath(os.path.dirname(__file__)),
                release_stage=os.getenv('SS_SORAYA_RECO_RELEASE_STAGE'))
            handle_exceptions(app)
예제 #56
0
def use_storm(app):
  """Setup Storm."""
  app.after_request(close_connection)

  #アプリが例外を投げるとafter_request呼ばれないので
  #処理の開始前にもコネクションのロールバックをさせることで
  #デッドロックを防止する。念のため、シグナルもキャッチして同様に処理する。
  app.before_request(close_connection)
  
  from flask import request_finished, got_request_exception
  
  def request_finished_handler(sender, response):
    close_connection(response)
  request_finished.connect(request_finished_handler, app)
  
  def got_request_exception_handler(sender, exception):
    close_connection()
  got_request_exception.connect(got_request_exception_handler, app)
예제 #57
0
파일: postgres.py 프로젝트: dupuy/amagama
    def init_app(self, app):
        self.app = app
        # read config
        db_args = {'minconn': app.config.get('DB_MIN_CONNECTIONS', 2),
                   'maxconn': app.config.get('DB_MAX_CONNECTIONS', 20),
                   'database': app.config.get('DB_NAME'),
                   'user': app.config.get('DB_USER'),
                   'password': app.config.get('DB_PASSWORD', ''),
                   }
        if 'DB_HOST' in app.config:
            db_args['host'] = app.config.get('DB_HOST')
        if 'DB_PORT' in app.config:
            db_args['port'] = app.config.get('DB_PORT')

        self.pool = PersistentConnectionPool(**db_args)

        app.after_request(self.cleanup)

        got_request_exception.connect(self.bailout, app)
def init_rollbar(app):
    if 'ROLLBAR_ACCESS_TOKEN' in app.config:
        import rollbar.contrib.flask
        import rollbar

        rollbar.init(
            app.config['ROLLBAR_ACCESS_TOKEN'],
            app.config['ENV'],
            root=os.path.dirname(os.path.realpath(hah.__file__)),
            allow_logging_basic_config=False,
            exception_level_filters=[
                (werkzeug.exceptions.HTTPException, 'warning'),
            ]
        )

        got_request_exception.connect(rollbar.contrib.flask.report_exception, app)

        app.logger.info('[rollbar.init_rollbar] Rollbar enabled')
    else:
        app.logger.info('[rollbar.init_rollbar] Rollbar disabled')