Remove guard.history after setting in cache

[CalebCourier]

Currently, if guards are loaded from a config, their history is held in memory. We already have an endpoint for fetching history for a specific guard call that we use when communicating between the client and the server. This cache applies a 5 minute TTL on each history entry as well as limits the cache to only 50 entries to prevent memory leaks.

However, since the guards are now objects kept in memory in the config rather than constructed JIT from the database, history is still being held on the guard instances. We should delete/reset Guard.history to an empty Stack once a /validate call is done. We should also investigate other means of dumping/persisting history somewhere else via a logging API.

[CalebCourier]

If you're running into issues because of this, here are a couple ways you can break the glass and deal with the guard history. For both examples, you can add another file adjacent to your config.py and hook into the guardrails-api's app. These examples assume you're using the FastAPI implementation of guardrails-api (v0.1.x), but similar things can be done with the Flask version (v0.0.x).

Adding History Endpoints

If you actually care about the contents of the guard's history, you can extend the guardrails-api and add a couple extra endpoints to help you manage it. The below adds a GET and DELETE endpoint for history:

## guardrails_api_ext.py

from guardrails_api.app import create_app
from guardrails_api.api.guards import router, guard_client
from guardrails.classes.generic import Stack
from guardrails_api.utils.handle_error import handle_error


@router.delete("/guards/{guard_name}/history")
@handle_error
async def guard_history(guard_name: str):
    guard = guard_client.get_guard(guard_name)
    guard.history = Stack()
    return {"message": "Guard history cleared.", "status": 204}

@router.get("/guards/{guard_name}/history")
@handle_error
async def guard_history(guard_name: str):
    guard = guard_client.get_guard(guard_name)
    return [item.to_dict() for item in guard.history]



__all__ = ["create_app"]

## Start your app with a command similar to this:
# uvicorn --host 0.0.0.0 --port 8000  'guardrails_api_ext:create_app(None, "config.py")'

This gives you the option to cleanup history whenever you need to.

Using a Middleware

If you don't care about the contents of the guard history, you can use a middleware to clear it after every request:

## guardrails_api_middleware.py

from typing import Optional
from fastapi import Request
from guardrails_api.app import create_app as _create_app
from guardrails_api.api.guards import guard_client
from guardrails.classes.generic import Stack
from starlette.middleware.base import BaseHTTPMiddleware


class HistoryMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        print("Running HistoryMiddleware...")
        response = await call_next(request)
        for guard_name in guard_client.guards:
            print("deleting history on guard: ", guard_name)
            guard = guard_client.guards[guard_name]
            guard.history = Stack()

        return response


def create_app(
    env: Optional[str] = None, config: Optional[str] = None, port: Optional[int] = None
):
    app = _create_app(env, config, port)
    app.add_middleware(HistoryMiddleware)
    return app


__all__ = ["create_app"]

## Start your app with a command similar to this:
# uvicorn --host 0.0.0.0 --port 8000  'guardrails_api_middleware:create_app(None, "config.py")'

This will keep history from being kept at all.