FastAPI

There are several options for installing Rollbar in FastAPI applications.

The following examples use the async handler that requires the HTTPX package to be installed. It's okay if you don't want to use/install it. In this case, a default sync handler is used.

You may also want to install the python-multipart package that is required for parsing request body content (this is the FastAPI requirement).

Run the examples (saved as a main.py file) via ASGI server (e.g. Uvicorn, Hypercorn or Daphne):

uvicorn main:app

Be sure to replace POST_SERVER_ITEM_ACCESS_TOKEN with your project's post_server_item access token, which you can find in the Rollbar.com interface.

Check out FastAPI examples in our GitHub repository.

Integrate via middleware

It is also possible to report errors via middleware. This integration should work with all versions of FastAPI.
Please note that FastAPI doesn't allow middleware to collect a streaming content like a request body.

import fastapi
import rollbar
from rollbar.contrib.fastapi import ReporterMiddleware as RollbarMiddleware

# Initialize Rollbar SDK with your server-side access token
rollbar.init(
  'POST_SERVER_ITEM_ACCESS_TOKEN',
  environment='production',
  handler='async',
)

# Integrate Rollbar with FastAPI application
app = fastapi.FastAPI()
app.add_middleware(RollbarMiddleware)  # should be added as the first middleware

# Add an /error endpoint to cause an uncaught exception
async def localfunc(arg1, arg2, arg3):
    # Both local variables and function arguments will be sent to Rollbar
    # and available in the UI
    localvar = 'local variable'
    cause_error_with_local_variables

@app.get('/error')
async def read_error():
    await localfunc('func_arg1', 'func_arg2', 1)
    return {'result': "You shouldn't be seeing this"}

Integrate via FastAPI Router

Integration via the router allows to send payload with more data (e.g. a request body content).
This is recommended option for reporting uncaught errors. It requires FastAPI version 0.41.0 or later.

import fastapi
import rollbar
from rollbar.contrib.fastapi import add_to as rollbar_add_to

# Initialize Rollbar SDK with your server-side access token
rollbar.init(
  'POST_SERVER_ITEM_ACCESS_TOKEN',
  environment='production',
  handler='async',
  include_request_body=True
)

# Integrate Rollbar with FastAPI application before adding routes to the app
app = fastapi.FastAPI()
rollbar_add_to(app)

# Alternatively, you can integrate with any APIRouter
# router = fastapi.APIRouter()
# rollbar_add_to(router)

# Add an /error endpoint to cause an uncaught exception
async def localfunc(arg1, arg2, arg3):
    # Both local variables and function arguments will be sent to Rollbar
    # and available in the UI
    localvar = 'local variable'
    cause_error_with_local_variables

@app.get('/error')
async def read_error():
    await localfunc('func_arg1', 'func_arg2', 1)
    return {'result': "You shouldn't be seeing this"}

NOTE: If you are using multiple routers, you will need to call rollbar_add_to(router) directly after creating each new router. This needs to be done before adding routes to the router. This will also replace any custom APIRouter.route_class. Because of this, it is recommended that you use the middleware integration for most cases.

NOTE: By default, this integration allows to report some user errors (e.g. RequestValidationError or HTTPException). You can ignore the reporting any errors by using payload handler feature.

Integrate with `logging` handler

FastAPI LOGGING handler reports log entries. For example errors that happen outside of the router/middleware, such as in Celery job queue tasks that run in the background separate from web requests.
Note that using LoggerMiddleware is optional, however it allows adding a request object to the payload. If you would like to use it in Python 3.6, you must to install the aiocontextvars package. For later versions of Python (3.7+), this package is not necessary.

import logging

import fastapi
import rollbar

from rollbar.contrib.fastapi import LoggerMiddleware
from rollbar.logger import RollbarHandler

# Initialize Rollbar SDK with your server-side access token
rollbar.init(
    'ACCESS_TOKEN',
    environment='staging',
    handler='async',
)

# 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 FastAPI application to add request objects to the payload
app = fastapi.FastAPI()
app.add_middleware(LoggerMiddleware)  # should be added as the last middleware

# Add an endpoint
@app.get('/')
async def read_root():
    # Report log entries
    logger.critical('Critical message sent to Rollbar')
    logger.error('Error message sent to Rollbar')

    # Ignore log entries
    logger.warning('Warning message is not sent to Rollbar')
    logger.info('Info message is not sent to Rollbar')
    logger.debug('Debug message is not sent to Rollbar')

    return {'hello': 'world'}

Global access for FastAPI request objects

FastAPI doesn't provide global access for request objects. However, if you are using any of the Rollbar integrations described above, you can access it via rollbar.get_request().

The example below shows integration via LoggerMiddleware without reporting errors to Rollbar. This is minimal integration to have an access to request objects. Remember that you don't need to add LoggerMiddleware to your application if you already have integration enabled for catching errors by using other options described above.

If you would like to use this feature in Python 3.6, you must to install the aiocontextvars package. For later versions of Python (3.7+), this package is not necessary.

import fastapi
import rollbar
from rollbar.contrib.fastapi import LoggerMiddleware

# Integrate Rollbar with FastAPI application
app = fastapi.FastAPI()
app.add_middleware(LoggerMiddleware)  # should be added as the last middleware

async def get_user_agent():
    # Global access to the current request object
    request = rollbar.get_request()

    user_agent = request.headers['User-Agent']
    return user_agent

@app.get('/')
async def read_root():
    user_agent = await get_user_agent()
    return {'user-agent': user_agent}

Report a message

If you would like to report a message to Rollbar, you can use the function rollbar.report_message() or delegate awaitable task to your event loop:

import fastapi
import rollbar
from rollbar.lib._async import report_message

# Initialize Rollbar SDK with your server-side access token
rollbar.init(
    'ACCESS_TOKEN',
    environment='staging',
)

app = fastapi.FastAPI()

@app.get('/)
async def read_root():
    await report_message('This is a message')
    return {'hello': 'world'}

This feature requires the HTTPX package to be installed.

Help / Support

If you run into any issues, please email us at [email protected]

For bug reports, please open an issue on GitHub.