Integrating Request Validation and Logging

Welcome to the final lesson of "Exposing Your Code Translator with FastAPI"! You’ve come a long way — starting from the basics of API design, building a clean architecture, and integrating your Haystack-powered translation pipeline. Now, it’s time to make your code translator truly production-ready by adding two essential features: request validation and logging. These are the finishing touches that transform a working prototype into a reliable, professional API.

In this lesson, you’ll learn how to ensure your API only accepts well-formed data and how to keep a detailed record of every translation request and response. These improvements will help you catch errors early, provide clear feedback to users, and make your service much easier to monitor and debug. Let’s dive in and give your project the polish it deserves!

Before we get hands-on, let’s build some intuition around data validation. When your API receives data from the outside world, you can’t assume it’s always correct or safe. For example, what if a client forgets to include the code to translate or tries to translate into a language your system doesn’t support? Without validation, these cases could cause confusing errors or even break your application.

This is where Pydantic comes in. Pydantic is a powerful library that lets you define exactly what data your API expects, and it automatically checks incoming requests for you. With Pydantic, you can:

• Specify required fields and their types;
• Add constraints, like minimum length or allowed values;
• Get clear, structured error messages when something’s wrong.

For instance, you might want to ensure that the code field is never empty and that the target_language is always a string. Pydantic makes this both easy and explicit, so your API is safer and your users get better feedback.

Let’s see how to use Pydantic to define the data your API will accept and return. In FastAPI, you create models by subclassing BaseModel and using the Field function to add constraints and descriptions.

from pydantic import BaseModel, Field

class TranslationRequest(BaseModel):
    code: str = Field(..., description="The code to translate", min_length=1)
    target_language: str = Field(..., description="The target programming language")

Here, both fields are required (thanks to ...), and code must be at least one character long. This means FastAPI will automatically reject any request that’s missing these fields or has an empty code string.

For responses, you can define models to ensure your API always returns data in a predictable format:

class TranslationResponse(BaseModel):
    translated_code: str = Field(..., description="The translated code as a markdown code block")
    explanation: str = Field(..., description="A brief explanation of the translation steps")

You can also create models for listing supported languages and for error messages:

from typing import List

class SupportedLanguagesResponse(BaseModel):
    languages: List[str]

class ErrorResponse(BaseModel):
    detail: str = Field(..., description="A human-readable error message.")

By using these models, you make your API self-documenting and much easier to use — clients always know what to send and what to expect in return.

With your models in place, let’s see how they improve your controller logic. Instead of manually parsing and checking the request body, you can let FastAPI handle validation for you by declaring your model as a parameter.

from fastapi import HTTPException, status

async def translate_code_handler(request: TranslationRequest):
    # FastAPI has already validated the request fields and types
    code = request.code
    target_language = request.target_language.lower()

    # Business logic validation: check for supported language
    if target_language not in service.get_supported_languages():
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail=f"Target language '{target_language}' is not supported."
        )

    try:
        result = service.run_code_translation(code, target_language)
        return TranslationResponse(**result)
    except Exception:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Translation failed. Please try again later."
        )

Notice how much cleaner this is! FastAPI and Pydantic take care of the basic checks, so you can focus on your business logic — like making sure the target language is supported. If validation fails, FastAPI automatically returns a helpful error message to the client.

Now, let’s talk about middleware. Middleware is a way to run code before and after every request your API handles. It’s perfect for tasks like logging, authentication, or adding custom headers.

In FastAPI, you create middleware by subclassing BaseHTTPMiddleware and implementing a dispatch method. Here’s a simple example that logs each request and response:

from starlette.middleware.base import BaseHTTPMiddleware
import logging
import sys

# Set up logging to print to the console
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    stream=sys.stdout
)
logger = logging.getLogger("code_translator_api")

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        logger.info(f"Request: {request.method} {request.url}")
        response = await call_next(request)
        logger.info(f"Response status: {response.status_code}")
        return response

This middleware uses Python’s built-in logging module. The basicConfig function sets up the log format and level, while getLogger creates a logger you can use throughout your app. Each time a request comes in, the middleware logs the method and URL, then logs the response status after processing.

For more detailed tracking, you can also log the request body and how long each request takes. This kind of logging is invaluable for debugging and understanding how your API is used in practice.

Let’s see how to connect everything together in your FastAPI application. You add your middleware and register your routes, specifying which models to use for requests and responses.

from fastapi import FastAPI

app = FastAPI(
    title="Code Translator API",
    description="A simple API for code translation using Haystack and LLMs.",
    version="0.2.0"
)

# Add your logging middleware
app.add_middleware(LoggingMiddleware)

# Register your API routes (assume router is already set up)
app.include_router(api_router, prefix="/api")

When defining your routes, you can specify the expected response models and document possible error responses:

router.post(
    "/translate",
    tags=["Translation"],
    response_model=TranslationResponse,
    responses={
        422: {"model": ErrorResponse, "description": "Validation Error"},
        500: {"model": ErrorResponse, "description": "Internal Server Error"},
    }
)(translate_code_handler)

This ensures that your API is not only robust but also well-documented. Clients can see exactly what to expect, and you get clear, consistent error handling for free.

Let's look at what your logging statements will actually produce when your API handles requests. Here's a sample of console output:

2025-02-15 14:23:45,123 INFO Request: POST http://localhost:8000/api/translate
2025-02-15 14:23:47,456 INFO Response status: 200
...
2025-02-15 14:24:12,789 INFO Request: POST http://localhost:8000/api/translate
2025-02-15 14:24:13,012 INFO Response status: 422

This simple logging gives you valuable visibility into your API's operation. You can see timestamps for each request, the HTTP method and endpoint being called, and the resulting status code. With this information, you can quickly identify successful translations (status 200) versus validation errors (status 422), making it much easier to troubleshoot issues when they arise.

You’ve now added the finishing touches to your code translator API, making it both robust and professional. By combining strong request validation with comprehensive logging, you’ve set up your service for reliability, maintainability, and easy troubleshooting.

As you move forward, keep these patterns in mind — they’re the foundation of any high-quality API. Take a moment to reflect on how far you’ve come, and get ready to put your new skills into practice in the exercises that follow. Great work reaching the end of this course!