OpenLLMetry e Sidecar: Observabilidade LLM Sem Alterar Seu Código

A observabilidade em aplicações web modernas, especialmente aquelas que utilizam Large Language Models (LLMs), é crucial para garantir o desempenho e a estabilidade. Monitorar o comportamento desses modelos, desde a entrada (prompts) até a saída (respostas), permite identificar gargalos, otimizar o uso de recursos e depurar problemas com maior eficiência. No entanto, integrar ferramentas de observabilidade diretamente no código da aplicação pode ser intrusivo e complexo. É aí que o padrão Sidecar, combinado com o OpenLLMetry, entra em cena para simplificar este processo.

O Que é OpenLLMetry?

OpenLLMetry, construído sobre o OpenTelemetry, é um framework de observabilidade de código aberto projetado para fornecer visibilidade detalhada na execução de aplicações que utilizam LLMs. Ele automatiza a instrumentação de provedores populares de LLMs, como OpenAI, Anthropic e Azure, bem como de bancos de dados vetoriais como Pinecone, Milvus e Chroma. Ao integrar o OpenLLMetry, você obtém acesso a rastreamento distribuído de alta fidelidade, permitindo visualizar todo o ciclo de vida de uma requisição, desde o prompt inicial e os passos de geração aumentada por recuperação (RAG) até a resposta final do modelo. Isso garante que você possa identificar pontos problemáticos, avaliar o desempenho do modelo e rastrear o uso de tokens em toda a sua infraestrutura.

O Padrão Sidecar: Uma Abordagem Modular

O padrão Sidecar funciona implantando um contêiner "sidecar" secundário ao lado do contêiner principal da aplicação dentro do mesmo ambiente de execução, como um pod Kubernetes ou um namespace de rede compartilhada. A lógica central reside na separação de preocupações, onde o contêiner da aplicação permanece focado exclusivamente na sua lógica de negócios, enquanto o sidecar lida com tarefas transversais, como rastreamento distribuído, registro de logs ou proxying de tráfego. Um pré-requisito fundamental para este padrão é o uso de imagens de contêiner; tanto a aplicação quanto o sidecar devem ser empacotados como imagens independentes para permitir que sejam "conectados". Esta modularidade permite que o sidecar intercepte requisições, como chamadas à API LLM, e adicione instrumentação OpenTelemetry sem exigir nenhuma alteração de código na imagem da aplicação principal.

Evoluindo a Observabilidade: A Mudança para o Padrão Sidecar

Tradicionalmente, a integração de observabilidade envolvia modificar o código da aplicação para adicionar bibliotecas de rastreamento e métricas. Embora funcional, essa abordagem tem desvantagens significativas:

• Intrusividade: Adicionar código de observabilidade diretamente na aplicação pode torná-la mais complexa e difícil de manter.
• Acoplamento: A aplicação se torna dependente das bibliotecas de observabilidade, dificultando a troca ou atualização dessas ferramentas.
• Linguagem-específica: As bibliotecas de observabilidade geralmente são específicas para cada linguagem de programação, o que pode ser problemático em ambientes multi-linguagem.

O padrão Sidecar resolve esses problemas, permitindo que a observabilidade seja adicionada sem modificar o código da aplicação. Isso oferece uma série de vantagens:

• Desacoplamento: A aplicação permanece independente das ferramentas de observabilidade, facilitando a manutenção e atualização.
• Reutilização: O mesmo sidecar pode ser usado com várias aplicações, independentemente da linguagem de programação.
• Centralização: A configuração e o gerenciamento da observabilidade são centralizados no sidecar, simplificando a administração.

Construindo com Bob: Um Exemplo Prático

Para demonstrar o poder do padrão Sidecar com OpenLLMetry, foi desenvolvido um projeto que consiste em duas partes principais:

1. Uma aplicação simples: Uma aplicação Flask que utiliza o Ollama para inferência de LLM. Esta aplicação não contém nenhum código de rastreamento ou dependências OpenTelemetry.
2. Um sidecar OpenLLMetry: Um proxy transparente que intercepta as chamadas à API Ollama e adiciona instrumentação OpenTelemetry usando o Traceloop SDK.

A aplicação e o sidecar são executados em contêineres separados, mas compartilham o mesmo ambiente de rede. Quando a aplicação faz uma chamada à API Ollama, o sidecar intercepta a requisição, adiciona spans OpenTelemetry, captura prompts, respostas e uso de tokens, e então encaminha a requisição para o Ollama. Os traces são então exportados para um coletor OpenTelemetry e visualizados em uma ferramenta como o Jaeger.

O código da aplicação é extremamente simples e focado na lógica de negócios. Por exemplo, a função `chat` recebe um prompt e retorna a resposta do LLM:

@app.route('/chat', methods=['POST'])
def chat():
    """
    Chat endpoint - accepts a prompt and returns a response
    """
    data = request.get_json()
    prompt = data['prompt']
    response = client.chat(model=OLLAMA_MODEL, messages=[{'role': 'user', 'content': prompt}])
    return jsonify({"response": response['message']['content']}), 200

Observe que não há código relacionado a observabilidade nesta função. Todo o rastreamento é feito pelo sidecar.

Implementação do Sidecar OpenLLMetry

O sidecar é implementado como um proxy HTTP que intercepta todas as requisições para a API Ollama. Ele usa o Traceloop SDK para adicionar spans OpenTelemetry e capturar informações relevantes sobre as chamadas LLM. O código do sidecar é o seguinte:

@task(name="ollama_api_call")
def proxy_ollama_request(method, path, headers, data, query_string):
    """
    Proxy request to Ollama with OpenLLMetry tracing.
    """
    upstream_url = f"{OLLAMA_UPSTREAM}/{path}"
    upstream_response = requests.request(
        method=method,
        url=upstream_url,
        headers={k: v for k, v in headers if k.lower() != 'host'},
        data=data,
        allow_redirects=False,
        timeout=300
    )
    return Response(
        upstream_response.content,
        status=upstream_response.status_code,
        headers=dict(upstream_response.headers)
    )

@workflow(name="ollama_proxy")
@app.route('/', defaults={'path': ''}, methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
@app.route('/<path:path>', methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
def proxy(path):
    """
    Main proxy endpoint.
    """
    return proxy_ollama_request(
        method=request.method,
        path=path,
        headers=request.headers,
        data=request.data,
        query_string=request.query_string
    )

O decorador `@task` cria automaticamente spans OpenTelemetry para cada chamada à API Ollama. O decorador `@workflow` cria um span pai para toda a requisição.

Arquitetura Flexível: Suporte Multi-Plataforma

O projeto foi projetado com uma estrutura modular para suportar várias estratégias de implantação, garantindo que a observabilidade permaneça "plugável" independentemente do ambiente. A arquitetura separa a lógica de negócios da infraestrutura de rastreamento. Isso resulta em uma configuração abrangente onde o OpenLLMetry opera como um proxy transparente, interceptando o tráfego entre a aplicação e o motor LLM. Seja implantando via Docker Compose para testes locais rápidos ou usando Kubernetes (Minikube) para uma simulação de nível de produção, o padrão sidecar permanece consistente.

Comparação: Sidecar vs Rastreamento Integrado

A tabela a seguir resume as principais diferenças entre o padrão Sidecar e o rastreamento integrado:

Conclusão: Um Futuro de Observabilidade Simplificada

A combinação do padrão Sidecar com o OpenLLMetry representa um avanço significativo na forma como abordamos a observabilidade em aplicações web, especialmente aquelas que utilizam LLMs. Ao desacoplar a lógica de observabilidade da lógica de negócios, podemos criar aplicações mais modulares, fáceis de manter e escaláveis. Além disso, a capacidade de adicionar observabilidade sem modificar o código da aplicação abre novas possibilidades para ambientes multi-linguagem e equipes com diferentes níveis de especialização. O futuro da observabilidade está na simplificação e na automação, e o padrão Sidecar com OpenLLMetry é um passo importante nessa direção. A capacidade de monitorar e otimizar aplicações LLM de forma transparente e não intrusiva será essencial para o sucesso de projetos que dependem cada vez mais da inteligência artificial.