def transform_and_roll_out():
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
sys.excepthook = uncaught_ex_handler
parser = create_argparser()
args = parser.parse_args()
configuration = get_bot_defaults()
if args.conf:
with open(args.conf) as cfile:
configuration.update(parse_config(cfile))
# Environment variables override configuration file settings
env_config = get_environment_configuration()
configuration.update(env_config)
if ROLLBAR_ACCESS_TOKEN in configuration:
rollbar.init(configuration[ROLLBAR_ACCESS_TOKEN],
configuration[ROLLBAR_ENVIRONMENT])
rollbar_handler = RollbarHandler()
rollbar_handler.setLevel(logging.ERROR)
logging.getLogger('').addHandler(rollbar_handler)
# This is hack-city, but since we're constructing the redis data
# after the fact, we'll now bolt the database back into the baseclass
walrus = Walrus(host=configuration[REDIS_URL],
port=configuration[REDIS_PORT],
password=configuration[REDIS_PASSWORD])
AutoBotBaseModel.set_database(walrus)
bot = AutoBot(configuration)
bot.run(args.forever, args.interval)
def _create_logger(self):
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
rollbar_handler = RollbarHandler(_test_access_token, _test_environment)
rollbar_handler.setLevel(logging.WARNING)
logger.addHandler(rollbar_handler)
return logger
def setup_rollbar_log_handler(rollbar_settings: Dict[str, str]) -> None:
"""
All log messages with level ERROR or higher will be sent to Rollbar
"""
rollbar.init(**rollbar_settings)
rollbar_handler = RollbarHandler()
rollbar_handler.setLevel(logging.ERROR)
root_logger = logging.getLogger()
root_logger.addHandler(rollbar_handler)
def get_logger(self, name):
logger = logging.getLogger(name)
logger.setLevel(self.log_level)
has_stream_handler = any(
isinstance(handler, logging.StreamHandler)
for handler in logger.handlers
)
if not has_stream_handler:
stream_handler = logging.StreamHandler()
stream_handler.setLevel(self.log_level)
stream_handler.setFormatter(logging.Formatter(
name + ': %(levelname)s: %(asctime)s %(message)s'
))
logger.addHandler(stream_handler)
has_file_handler = any(
isinstance(handler, handlers.RotatingFileHandler)
for handler in logger.handlers
)
if self.logfile_root is not None and not has_file_handler:
ensure_path_exists(self.logfile_root)
logfile_path = os.path.join(self.logfile_root, "{0}.log".format(name))
file_handler = handlers.RotatingFileHandler(logfile_path,
backupCount=20,
maxBytes=10000000)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter(
'%(levelname)s: %(asctime)s %(message)s'
))
logger.addHandler(file_handler)
if is_rollbar_available():
import rollbar
from rollbar.logger import RollbarHandler
has_rollbar_handler = any(
isinstance(handler, RollbarHandler)
for handler in logger.handlers
)
if not has_rollbar_handler:
rb_secret = os.environ['ROLLBAR_SECRET']
rb_environment = os.environ['ROLLBAR_ENVIRONMENT']
if not rollbar._initialized:
rollbar.init(rb_secret, rb_environment)
rb_handler = RollbarHandler()
rb_handler.setLevel(logging.WARNING)
logger.addHandler(rb_handler)
return logger
def init_app(cls, app):
Config.init_app(app)
assert os.environ.get('SECRET_KEY'), 'SECRET_KEY IS NOT SET!'
rollbar.init('ROLLBAR_ACCESS_TOKEN')
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# report WARNING and above to Rollbar
rollbar_handler = RollbarHandler(history_size=3)
rollbar_handler.setLevel(logging.WARNING)
# gather history for DEBUG+ log messages
rollbar_handler.setHistoryLevel(logging.DEBUG)
# attach the history handler to the root logger
logger.addHandler(rollbar_handler)
from flask import Flask
import rollbar
from rollbar.logger import RollbarHandler
ACCESS_TOKEN = '...'
ENVIRONMENT = 'development'
rollbar.init(ACCESS_TOKEN, ENVIRONMENT)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# report WARNING and above to Rollbar
rollbar_handler = RollbarHandler(history_size=3)
rollbar_handler.setLevel(logging.WARNING)
# gather history for DEBUG+ log messages
rollbar_handler.setHistoryLevel(logging.DEBUG)
# attach the history handler to the root logger
logger.addHandler(rollbar_handler)
app = Flask(__name__)
@app.route('/')
def root():
logger.info('about to call foo()')
try:
from starlette.applications import Starlette
from starlette.responses import PlainTextResponse
# Initialize Rollbar SDK with your server-side ACCESS_TOKEN
rollbar.init(
'ACCESS_TOKEN',
environment='staging',
handler='async', # For asynchronous reporting use: default, async or httpx
)
# Set root logger to log DEBUG and above
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# Report ERROR and above to Rollbar
rollbar_handler = RollbarHandler()
rollbar_handler.setLevel(logging.ERROR)
# Attach Rollbar handler to the root logger
logger.addHandler(rollbar_handler)
# Integrate Rollbar with Starlette application
app = Starlette()
app.add_middleware(LoggerMiddleware) # should be added as the last middleware
# GET query params will be sent to Rollbar and available in the UI
# $ curl http://localhost:8888?param1=hello¶m2=world
@app.route('/')
async def root(request):
# Report log entries
def add_rollbar_handler(logger, level=logging.WARNING):
if settings.ROLLBAR_ACCESS_TOKEN is not None:
rollbar_handler = RollbarHandler()
rollbar_handler.setLevel(level)
logger.addHandler(rollbar_handler)
(r"/api/" + version +
"/support/(?P<run_numero_url>\d+)/recovery/(?P<method>\d+)$",
support.SupportHandler),
(r"/api/" + version + "/support/(?P<run_numero_url>\d+)/email$",
support.SupportHandler),
(r"/api/" + version + "/support/agents/users$",
user_agent.SupportAgentsHandler),
(r"/api/" + version + "/support/agents/users/(?P<run_numero_url>\d+)$",
user_agent.SupportAgentsHandler)
]
# Error application
logger = logging.getLogger('tornado.application')
# report ERROR and above to Rollbar
rollbar_handler = RollbarHandler(
access_token='3d825d37bb6a47df87ddd8444dd69fb2',
environment='production',
level=logging.ERROR)
# attach the handlers to the root logger
logger.addHandler(rollbar_handler)
# app
tornado_app = tornado.web.Application(handlers,
default_handler_class=base.BaseHandler,
**settings)
# Main app
application = tornado.wsgi.WSGIAdapter(tornado_app)
if __name__ == "__main__":
import gevent.wsgi
server = gevent.wsgi.WSGIServer(("", 8888), application)
server.serve_forever()