Dans mon précédent article sur Pydantic, je vous ai présenté Logfire dans l’un des exemples de code comme une plateforme d’observabilité conçue pour fournir aux développeurs des informations sur les applications Python. Dans cet article, vous plongerez en profondeur dans Logfire et ses capacités qui simplifieront finalement votre parcours d’observabilité, du traçage au débogage en passant par le journalisation.
Logfire est une plateforme d’observabilité innovante développée par les créateurs de Pydantic, conçue pour fournir aux développeurs des informations puissantes sur leurs applications Python. Basé sur les mêmes principes qui ont fait le succès de Pydantic, Logfire vise à rendre l’observabilité facile à mettre en œuvre et à comprendre tout en offrant des informations approfondies sur le comportement de l’application.
Principales fonctionnalités
Intégration transparente
Logfire s’intègre facilement aux projets Python existants, nécessitant une configuration minimale. Avec quelques lignes de code seulement, les développeurs peuvent commencer à recueillir des données précieuses sur les performances et le comportement de leur application.
Intégration avec Pydantic
Logfire offre une intégration exceptionnelle avec les modèles Pydantic. Cela permet aux développeurs d’obtenir des informations sans précédent sur la validation des données et l’utilisation des modèles dans leurs applications.
Instrumentation automatique
Logfire peut instrumenter automatiquement des bibliothèques et des frameworks populaires, réduisant le besoin de journalisation et de traçage manuels. Cette fonctionnalité permet de gagner du temps et garantit une couverture complète du comportement de l’application.
Compatible avec OpenTelemetry
Construit sur OpenTelemetry, Logfire assure la compatibilité avec les normes de l’industrie et permet des options flexibles d’exportation de données.
Prérequis
- Connectez-vous à Logfire.
- Suivez les invites pour créer votre compte. Ce compte vous aidera à organiser vos projets.
- Depuis votre organisation, cliquez sur Nouveau projet pour créer votre premier projet.
Prise en main
Pour commencer à utiliser Logfire, suivez ces étapes simples :
Étape 1. Installez le package Logfire avec la commande ci-dessous. Si vous utilisez Jupyter Notebook, exécutez !pip install logfire.
pip install logfire
Étape 2. Authentifiez-vous auprès du service Logfire. Cela ouvrira un navigateur et demandera les identifiants de connexion à Logfire.
logfire auth
3. Configurez Logfire dans votre application. Une fois le package installé, vous devez utiliser les commandes ci-dessous pour configurer Logfire.
import logfire
logfire.configure()
Vous pouvez suivre les étapes dans le cadre de la configuration de votre projet :
Utilisation de base
Un span dans Logfire est un élément essentiel d’une trace. Vous pouvez définir un span avec logfire.span. Dans l’exemple ci-dessous, le span externe définit le sujet – l’anniversaire de l’utilisateur. L’utilisateur sera invité à fournir sa date de naissance et capturé via le terminal ou l’invite de commande. L’espace capture la date de naissance entrée par l’utilisateur.
Voici un exemple simple de comment utiliser Logfire pour le traçage manuel:
import logfire
from datetime import date
logfire.configure()
logfire.info('Hello, {name}!', name='world')
with logfire.span('Asking the user their {question}', question='age'):
user_input = input('How old are you [YYYY-mm-dd]? ')
dob = date.fromisoformat(user_input)
logfire.debug('{dob=} {age=!r}', dob=dob, age=date.today() - dob)
Si vous ne voyez pas la sortie DEBUG, cliquez sur Filtrer les données locales –> Niveaux –> debug.
Intégration Pydantic
Comme discuté dans mon article précédent, la fonction principale de Pydantic est la validation des données. Elle utilise des indications de type Python pour valider automatiquement la structure et les types de données. Lorsque vous définissez un modèle Pydantic, chaque champ est annoté avec son type attendu. Pydantic s’assure ensuite que les données attribuées à ces champs correspondent aux types spécifiés.
L’intégration de Logfire avec Pydantic est particulièrement puissante. Voici comment vous pouvez l’utiliser pour enregistrer les validations de modèles Pydantic:
from datetime import date
import logfire
from pydantic import BaseModel
logfire.configure()
logfire.instrument_pydantic()
class User(BaseModel):
name: str
country_code: str
dob: date
User(name='Anne', country_code='USA', dob='2000-01-01')
User(name='Ben', country_code='USA', dob='2000-02-02')
User(name='Charlie', country_code='GBR', dob='1990-03-03')
Cette configuration enregistrera automatiquement des détails sur toutes les validations de modèles Pydantic, fournissant des informations précieuses sur le traitement des données au sein de votre application.
Intégrations de Framework
Logfire propose des intégrations avec des frameworks et des bibliothèques Python populaires. Pour l’exemple de code Python ci-dessous, vous devez fournir la clé API OpenAI et installer les packages requis (FASTAPI, instructeur, OpenAI, etc.).
Pour commencer, FastAPI est un framework web Python qui aide les développeurs à créer des interfaces de programmation d’application (API). FastAPI est reconnu pour sa scalabilité, sa facilité d’utilisation et ses hautes performances.
Instructor est un package python qui vous aide à extraire facilement des données structurées comme JSON de la sortie LLMs.
Voici un exemple d’intégration de Logfire avec FastAPI, l’API OpenAI, et instructor:
from fastapi import FastAPI
from openai import AsyncOpenAI
import os
import instructor
import logfire
from pydantic import BaseModel
app = FastAPI()
openai_client = AsyncOpenAI(
api_key=os.environ.get("OPENAI_API_KEY"))
logfire.configure()
logfire.instrument_pydantic()
logfire.instrument_openai(openai_client)
logfire.instrument_fastapi(app)
client = instructor.from_openai(openai_client)
class UserData(BaseModel):
query: str
class UserDetail(BaseModel):
name: str
age: int
.post("/user", response_model=UserDetail)
async def endpoint_function(data: UserData) -> UserDetail:
user_detail = await client.chat.completions.create(
model="gpt-3.5-turbo",
response_model=UserDetail,
messages=[
{"role": "user", "content": f"Extract: `{data.query}`"},
],
)
return user_detail
Ce setup fournit un journal complet pour les requêtes FastAPI, les appels d’API OpenAI, et les validations de modèles Pydantic, offrant une vue holistique du comportement de votre application.
Conclusion
Logfire représente une avancée significative dans la rendant l’observabilité accessible et puissante pour les développeurs Python. Logfire permet aux développeurs de mieux comprendre et optimiser leurs applications en combinant facilité d’utilisation et insights approfondis. Que vous travailliez sur un petit projet ou une application à grande échelle, Logfire fournit les outils pour obtenir des insights précieux sur le comportement et les performances de votre code.
N’hésitez pas à montrer votre amour avec un like et à partager avec votre communauté de développeurs.
Source:
https://dzone.com/articles/logfire-uncomplicated-observability-for-python-app