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()