DEV Community

Cover image for 🚀 Como comunicar .NET 10 com Pydantic usando Logfire
Danilo O. Pinheiro, dopme.io
Danilo O. Pinheiro, dopme.io

Posted on

🚀 Como comunicar .NET 10 com Pydantic usando Logfire

#csharp #dotnet #python #devops

Uma implementação simples de observabilidade com OpenTelemetry

Quando pensamos no ecossistema Pydantic, normalmente associamos a tecnologia ao Python, validação de dados e aplicações de Inteligência Artificial. Porém, existe uma possibilidade muito interessante para aplicações .NET: utilizar o Pydantic Logfire como plataforma de observabilidade para uma aplicação construída em .NET 10.

E aqui está o ponto mais importante:

Não precisamos criar uma integração específica entre .NET e Pydantic.

O caminho mais simples é utilizar o OpenTelemetry, padrão aberto utilizado pelo Logfire. O .NET envia traces, métricas e logs através do protocolo OTLP, e o Logfire recebe e apresenta essas informações em sua plataforma. (logfire.pydantic.dev)

Neste artigo, vamos construir uma implementação simples utilizando .NET 10 + ASP.NET Core + OpenTelemetry + Logfire.

🧭 O que vamos construir?

A arquitetura será propositalmente simples:

┌──────────────────────┐
│      Cliente         │
└──────────┬───────────┘
           │ HTTP
           ▼
┌──────────────────────┐
│      .NET 10 API     │
│                      │
│ ASP.NET Core         │
│ ILogger              │
│ Activity             │
│ Metrics              │
└──────────┬───────────┘
           │
           │ OTLP / HTTP
           ▼
┌──────────────────────┐
│   Pydantic Logfire   │
│                      │
│ Logs                 │
│ Traces               │
│ Metrics              │
└──────────────────────┘
Enter fullscreen mode Exit fullscreen mode

O objetivo não é transformar o .NET em uma aplicação Python/Pydantic.

O objetivo é comunicar uma aplicação .NET com o ecossistema Pydantic através de um padrão de observabilidade aberto.

🧠 1. Onde entra o Pydantic?

O ecossistema Pydantic possui diferentes ferramentas.

Na imagem apresentada, podemos observar uma organização bastante interessante:

🏗️ Build

  • Pydantic AI
  • Pydantic Validation

🔄 Iterate

  • Pydantic Evals
  • Logfire Agent Optimization

🚀 Deploy & Monitor

  • Logfire Agent Monitoring
  • Logfire Infrastructure Monitoring
  • Logfire
  • Logfire AI Gateway

Para uma primeira implementação com .NET, entretanto, não precisamos começar por Pydantic AI, Evals ou AI Gateway.

A opção mais simples é:

.NET 10 → OpenTelemetry → Logfire

Isso reduz drasticamente a complexidade inicial.

O próprio Logfire informa que aplicações em linguagens compatíveis com OpenTelemetry podem enviar telemetria diretamente para sua infraestrutura. (logfire.pydantic.dev)

🔌 2. O que significa "comunicar .NET com Pydantic"?

É importante fazer uma distinção.

Não teremos necessariamente:

.NET
  ↓
Pydantic API
Enter fullscreen mode Exit fullscreen mode

A arquitetura será:

.NET
  ↓
OpenTelemetry
  ↓
OTLP
  ↓
Logfire
Enter fullscreen mode Exit fullscreen mode

O OTLP (OpenTelemetry Protocol) é justamente o protocolo utilizado para transportar dados de telemetria entre aplicações e backends compatíveis. (Microsoft Learn)

Isso também significa que a mesma aplicação poderia posteriormente enviar sua telemetria para outras plataformas compatíveis com OpenTelemetry.

🛠️ 3. Criando a API .NET 10

Vamos começar com uma aplicação mínima.

dotnet new webapi -n DotNetLogfire
cd DotNetLogfire
Enter fullscreen mode Exit fullscreen mode

Confira o projeto:

dotnet run
Enter fullscreen mode Exit fullscreen mode

Agora temos nossa API .NET 10.

📦 4. Instalando OpenTelemetry

Vamos instalar o exporter OTLP:

dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Enter fullscreen mode Exit fullscreen mode

Também podemos adicionar as instrumentações necessárias:

dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Instrumentation.AspNetCore
dotnet add package OpenTelemetry.Instrumentation.Http
Enter fullscreen mode Exit fullscreen mode

O pacote OpenTelemetry.Exporter.OpenTelemetryProtocol fornece o exporter OTLP para aplicações .NET e é compatível com net10.0. (NuGet)

🔐 5. Criando um token no Logfire

No Logfire, crie um projeto e gere um write token.

Esse token será utilizado pela aplicação para autenticar o envio da telemetria.

Não coloque o token diretamente no código:

// ❌ Não faça isso
var token = "meu-token-real";
Enter fullscreen mode Exit fullscreen mode

Prefira variável de ambiente:

LOGFIRE_TOKEN
Enter fullscreen mode Exit fullscreen mode

Isso permite manter credenciais fora do código-fonte.

A documentação do Logfire utiliza o header de autorização para autenticar os dados enviados através de OTLP. (logfire.pydantic.dev)

🌐 6. Configurando o endpoint do Logfire

Para uma configuração simples, podemos utilizar:

OTEL_EXPORTER_OTLP_ENDPOINT=https://logfire-us.pydantic.dev
Enter fullscreen mode Exit fullscreen mode

E:

OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
Enter fullscreen mode Exit fullscreen mode

Além disso:

OTEL_EXPORTER_OTLP_HEADERS=Authorization=SEU_TOKEN
Enter fullscreen mode Exit fullscreen mode

O Logfire documenta explicitamente essa configuração para clientes OpenTelemetry que não possuem um SDK específico do Logfire. (logfire.pydantic.dev)

Se seu projeto estiver utilizando a região europeia, utilize o endpoint correspondente do Logfire EU.

⚙️ 7. Configurando o OpenTelemetry no .NET

Agora vamos configurar o Program.cs.

using OpenTelemetry.Logs;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

var builder = WebApplication.CreateBuilder(args);

builder.Logging.AddOpenTelemetry(logging =>
{
    logging.IncludeFormattedMessage = true;
    logging.IncludeScopes = true;
});

builder.Services
    .AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        tracing
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation();
    })
    .WithMetrics(metrics =>
    {
        metrics
            .AddAspNetCoreInstrumentation()
            .AddRuntimeInstrumentation();
    })
    .UseOtlpExporter();

var app = builder.Build();

app.MapGet("/", () =>
{
    return Results.Ok(new
    {
        message = "Hello Logfire!",
        timestamp = DateTime.UtcNow
    });
});

app.Run();
Enter fullscreen mode Exit fullscreen mode

A estrutura segue o modelo recomendado pelo OpenTelemetry no .NET: ILogger para logs, ActivitySource para tracing e Meter para métricas. (Microsoft Learn)

📊 8. O que estamos enviando?

Agora temos três categorias principais.

📝 Logs

Gerados através de:

ILogger
Enter fullscreen mode Exit fullscreen mode

Por exemplo:

app.MapGet("/products", (
    ILogger<Program> logger) =>
{
    logger.LogInformation(
        "Consultando produtos");

    return Results.Ok(new[]
    {
        "Notebook",
        "Mouse",
        "Keyboard"
    });
});
Enter fullscreen mode Exit fullscreen mode

🔎 9. Traces

O OpenTelemetry consegue instrumentar automaticamente requisições HTTP do ASP.NET Core.

Por exemplo:

GET /products
      │
      ▼
ASP.NET Core
      │
      ▼
Controller / Endpoint
      │
      ▼
HttpClient
      │
      ▼
External API
Enter fullscreen mode Exit fullscreen mode

Esse fluxo pode ser representado como um trace.

A grande vantagem é conseguir entender onde uma requisição gastou tempo.

📈 10. Métricas

Também podemos trabalhar com métricas.

Por exemplo:

HTTP Requests
Request Duration
Active Requests
Runtime Metrics
GC
CPU
Memory
Enter fullscreen mode Exit fullscreen mode

O ASP.NET Core e o .NET já possuem diversas métricas instrumentadas, e o OpenTelemetry pode coletá-las. (Microsoft Learn)

🧪 11. Criando um endpoint para teste

Vamos criar um endpoint um pouco mais interessante:

app.MapGet("/orders/{id}", (
    int id,
    ILogger<Program> logger) =>
{
    logger.LogInformation(
        "Consultando pedido {OrderId}",
        id);

    if (id <= 0)
    {
        logger.LogWarning(
            "Pedido inválido: {OrderId}",
            id);

        return Results.BadRequest();
    }

    return Results.Ok(new
    {
        Id = id,
        Status = "Processed"
    });
});
Enter fullscreen mode Exit fullscreen mode

Agora podemos testar:

GET /orders/10
Enter fullscreen mode Exit fullscreen mode

E:

GET /orders/0
Enter fullscreen mode Exit fullscreen mode

Teremos dois comportamentos diferentes.

🔥 12. Gerando um erro proposital

Para entender melhor a observabilidade, podemos criar:

app.MapGet("/error", () =>
{
    throw new InvalidOperationException(
        "Erro de demonstração");
});
Enter fullscreen mode Exit fullscreen mode

Quando acessarmos:

GET /error
Enter fullscreen mode Exit fullscreen mode

teremos uma exceção.

O objetivo aqui é observar como o problema aparece no Logfire.

🔗 13. O fluxo completo

Agora nossa arquitetura está assim:

                    ┌───────────────────┐
                    │     Browser       │
                    │    Postman        │
                    │      Client       │
                    └─────────┬─────────┘
                              │
                              ▼
                    ┌───────────────────┐
                    │     .NET 10       │
                    │    ASP.NET Core   │
                    └─────────┬─────────┘
                              │
             ┌────────────────┼────────────────┐
             │                │                │
             ▼                ▼                ▼
          ILogger          Activity           Meter
             │                │                │
             └────────────────┼────────────────┘
                              ▼
                      ┌───────────────┐
                      │ OpenTelemetry │
                      └───────┬───────┘
                              │
                             OTLP
                              │
                              ▼
                     ┌─────────────────┐
                     │    Logfire      │
                     │   Pydantic      │
                     └─────────────────┘
Enter fullscreen mode Exit fullscreen mode

Essa é a parte mais interessante da implementação.

Não criamos um SDK proprietário para integrar o .NET.

Utilizamos um padrão aberto.

🧩 14. Por que essa abordagem é interessante?

Imagine que amanhã você queira trocar o Logfire.

A aplicação não precisa ser completamente reescrita.

Poderíamos direcionar o OpenTelemetry para:

.NET
 │
 └── OpenTelemetry
       │
       ├── Logfire
       ├── Grafana
       ├── Datadog
       ├── Azure Monitor
       ├── New Relic
       └── Outro backend OTLP
Enter fullscreen mode Exit fullscreen mode

Essa independência é justamente uma das principais vantagens do OpenTelemetry. (Microsoft Learn)

🏗️ 15. E onde entra o Pydantic AI?

Aqui começa uma arquitetura ainda mais interessante.

Podemos ter:

             ┌─────────────────┐
             │     .NET 10     │
             │       API       │
             └────────┬────────┘
                      │
                      │ HTTP
                      ▼
             ┌─────────────────┐
             │  Pydantic AI   │
             │     Agent      │
             └────────┬────────┘
                      │
                      ▼
                   LLM
                      │
                      ▼
                 Logfire
Enter fullscreen mode Exit fullscreen mode

Nesse cenário, o .NET poderia ser responsável por:

  • APIs
  • autenticação
  • regras de negócio
  • banco de dados
  • integrações corporativas

Enquanto o ecossistema Pydantic poderia assumir:

  • agentes
  • validação
  • avaliação
  • workflows de IA

E o Logfire poderia fornecer uma camada de observabilidade.

🤖 16. Uma arquitetura híbrida .NET + Pydantic

Uma arquitetura mais completa poderia ficar assim:

                  Client
                     │
                     ▼
              ┌──────────────┐
              │   .NET 10    │
              │     API      │
              └──────┬───────┘
                     │
          ┌──────────┴──────────┐
          │                     │
          ▼                     ▼
     Business Rules         Pydantic AI
          │                     │
          │                     ▼
          │                    LLM
          │                     │
          └──────────┬──────────┘
                     ▼
                OpenTelemetry
                     │
                     ▼
                  Logfire
Enter fullscreen mode Exit fullscreen mode

Isso cria uma separação interessante entre aplicação empresarial e camada de inteligência artificial.

🔐 17. Segurança

Um ponto extremamente importante é evitar enviar informações sensíveis para uma plataforma de observabilidade.

Por exemplo, evite:

logger.LogInformation(
    "Cartão: {CardNumber}",
    cardNumber);
Enter fullscreen mode Exit fullscreen mode

Ou:

logger.LogInformation(
    "Token: {Token}",
    token);
Enter fullscreen mode Exit fullscreen mode

Prefira:

logger.LogInformation(
    "Pagamento processado para o pedido {OrderId}",
    orderId);
Enter fullscreen mode Exit fullscreen mode

O Logfire também possui mecanismos de processamento e redaction através do ecossistema OpenTelemetry Collector para cenários em que dados precisam ser filtrados antes do envio. (logfire.pydantic.dev)

🐳 18. E se eu quiser usar Docker?

A aplicação pode continuar sendo executada normalmente:

docker build -t dotnet-logfire .
Enter fullscreen mode Exit fullscreen mode

E:

docker run \
-e OTEL_EXPORTER_OTLP_ENDPOINT=https://logfire-us.pydantic.dev \
-e OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
-e OTEL_EXPORTER_OTLP_HEADERS="Authorization=SEU_TOKEN" \
-p 8080:8080 \
dotnet-logfire
Enter fullscreen mode Exit fullscreen mode

Assim, as configurações permanecem fora da imagem.

📦 19. E o OpenTelemetry Collector?

Em uma arquitetura maior, podemos adicionar um Collector:

.NET 10
   │
   ▼
OpenTelemetry
   │
   ▼
OTel Collector
   │
   ├──────────────► Logfire
   │
   ├──────────────► Grafana
   │
   └──────────────► Datadog
Enter fullscreen mode Exit fullscreen mode

Isso é particularmente interessante quando existe necessidade de:

  • filtragem;
  • redaction;
  • transformação;
  • roteamento;
  • múltiplos backends.

O próprio Logfire documenta o uso do OpenTelemetry Collector como camada intermediária para processamento e encaminhamento da telemetria. (logfire.pydantic.dev)

🧠 20. O que aprendemos?

A implementação demonstrou algo importante:

Integrar .NET com Pydantic não significa necessariamente consumir uma API Python diretamente.

Podemos utilizar o ecossistema de padrões que conecta as duas tecnologias.

A arquitetura utilizada foi:

.NET 10
   ↓
OpenTelemetry
   ↓
OTLP
   ↓
Pydantic Logfire
Enter fullscreen mode Exit fullscreen mode

E isso nos permite observar:

Logs
Traces
Metrics
Enter fullscreen mode Exit fullscreen mode

em uma plataforma construída para observabilidade de aplicações e sistemas de IA. O Logfire atualmente se posiciona justamente como uma plataforma de observabilidade baseada em OpenTelemetry para aplicações, serviços e agentes de IA. (Pydantic)

🚀 21. Próximo passo: .NET + Pydantic AI

Depois dessa primeira comunicação, podemos evoluir a arquitetura.

Nível 1 — Observabilidade 

.NET 10
   ↓
OpenTelemetry
   ↓
Logfire
Enter fullscreen mode Exit fullscreen mode

Nível 2 — API + Agent 

.NET 10
   ↓
Pydantic AI
   ↓
LLM
   ↓
Logfire
Enter fullscreen mode Exit fullscreen mode

Nível 3 — Arquitetura completa 

                 Client
                   │
                   ▼
                .NET 10
                   │
          ┌────────┴────────┐
          ▼                 ▼
      Database        Pydantic AI
                            │
                            ▼
                           LLM
                            │
                            ▼
                       OpenTelemetry
                            │
                            ▼
                         Logfire
Enter fullscreen mode Exit fullscreen mode

Essa evolução abre espaço para aplicações híbridas envolvendo .NET, agentes de IA, LLMs, observabilidade e arquitetura distribuída.

✅ Conclusão

O mais interessante nessa integração é justamente sua simplicidade.

Para começar, não precisamos criar uma ponte complexa entre .NET e Python.

Podemos utilizar:

.NET 10 + OpenTelemetry + OTLP + Logfire.

Com poucas configurações, uma aplicação .NET consegue enviar logs, traces e métricas para o Logfire, aproveitando um padrão aberto e independente de fornecedor. (logfire.pydantic.dev)

E essa abordagem pode ser o primeiro passo para uma arquitetura muito maior, conectando APIs .NET, Pydantic AI, agentes, LLMs e observabilidade.

Talvez a melhor forma de começar com Pydantic no .NET não seja começar pelo Pydantic — mas pelo OpenTelemetry.

🤝 Conecte-se Comigo

Se você trabalha com .NET moderno e quer evoluir em temas como arquitetura, C#, Inteligência Artificial, observabilidade, DevOps ou interoperabilidade, vamos conversar:

  • 🌐 shifters.dev
  • 💼 LinkedIn
  • 💻 Dev.to
  • ✍️ Medium
  • ✍️ Substack
  • 📬 contato@dopme.io

🔗 Referências

Eu lhes dou este novo mandamento: amem uns aos outros. Assim como eu os amei, amem também uns aos outros.
João 13:34

Top comments (0)