def setup_api(title: str, description: str, version: str,
cors_origins: List[str], routers: List):
middleware = [
Middleware(RawContextMiddleware,
plugins=(plugins.RequestIdPlugin(),
plugins.CorrelationIdPlugin()))
]
app = FastAPI(title=title,
description=description,
version=version,
middleware=middleware)
if cors_origins:
_LOGGER.debug(
f'Adding CORS middleware for origins {", ".join(cors_origins)}')
app.add_middleware(
CORSMiddleware,
allow_origins=cors_origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# FastAPIInstrumentor.instrument_app(app)
# PrometheusInstrumentator().instrument(app).expose(app)
for router in routers:
app.include_router(router.router)
return app
def gen_middleware_config(middleware_class: Type,
response: Response) -> TestClient:
middleware = [
Middleware(
middleware_class,
plugins=(plugins.RequestIdPlugin(error_response=response), ),
)
]
app = Starlette(middleware=middleware)
client = TestClient(app)
return client
def __registerMiddleWares(self):
application = loadCordsMiddleware(self.applicationObject)
'''Load middlewares'''
if self.__startLogSystem():
application.middleware('http')(registerLoggerMiddleware(self.applicationObject))
application.middleware('http')(registerConfigMiddleware(self.applicationObject))
application.add_middleware(ContextMiddleware.with_plugins(
plugins.CorrelationIdPlugin(),
plugins.RequestIdPlugin(),
plugins.DateHeaderPlugin(),
plugins.ForwardedForPlugin(),
plugins.UserAgentPlugin(),
))
def test_force_new_uuid():
app_force_uuid = Starlette(middleware=[
Middleware(
ContextMiddleware,
plugins=(plugins.RequestIdPlugin(force_new_uuid=True), ),
)
])
force_uuid_client = TestClient(app_force_uuid)
@app_force_uuid.route("/")
async def index(request: Request) -> Response:
return Response(status_code=status.HTTP_204_NO_CONTENT)
response = force_uuid_client.get("/", headers=headers)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert HeaderKeys.request_id in response.headers
assert response.headers.get(HeaderKeys.request_id) != dummy_request_id
from fastapi import FastAPI, APIRouter, Depends
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel
get_method_name = "GET"
post_method_name = "POST"
trace_id_key = "unique_id"
default_trace_value = "unknown"
logger.add(lambda record: print(record, context[
header_keys.HeaderKeys.request_id], context[trace_id_key]),
level="INFO")
app = FastAPI()
app.add_middleware(
middleware.ContextMiddleware,
plugins=(plugins.RequestIdPlugin(), ),
)
router = APIRouter()
class Item(BaseModel):
name: Optional[str] = None
description: Optional[str] = None
price: Optional[float] = None
tax: float = 10.5
tags: List[str] = []
items = {
"foo": {
from fastapi import FastAPI
from ariadne.asgi import GraphQL
from app.server.graphql.schema import schema
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.middleware import Middleware
from starlette.middleware.sessions import SessionMiddleware
from starlette_context import context, plugins
from starlette_context.middleware import ContextMiddleware
middleware = [
Middleware(
ContextMiddleware,
plugins=(plugins.RequestIdPlugin(), plugins.CorrelationIdPlugin()),
)
]
app = FastAPI(middleware=middleware)
app.add_route("/graphql", GraphQL(schema, debug=True))
class LoggingMiddleware(BaseHTTPMiddleware):
"""Example logging middleware."""
async def dispatch(self, request: Request,
call_next: RequestResponseEndpoint) -> Response:
await logger.info("request log", request=request)
response = await call_next(request)
await logger.info("response log", response=response)
return response
middlewares = [
Middleware(
RawContextMiddleware,
plugins=(
plugins.CorrelationIdPlugin(),
plugins.RequestIdPlugin(),
),
),
Middleware(LoggingMiddleware),
]
app = Starlette(debug=True, middleware=middlewares)
@app.on_event("startup")
async def startup_event() -> None:
from setup_logging import setup_logging
setup_logging()
from starlette import status
from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import Response
from starlette.testclient import TestClient
from starlette_context import middleware, plugins
from starlette_context.header_keys import HeaderKeys
app = Starlette(
middleware=[
Middleware(
middleware.ContextMiddleware, plugins=(plugins.RequestIdPlugin(),)
)
]
)
@app.route("/exc")
async def exc(request: Request):
raise Exception
@app.route("/")
async def index(request: Request):
return Response(status_code=status.HTTP_200_OK)
client = TestClient(app, raise_server_exceptions=False)
def plugin():
return plugins.RequestIdPlugin()
