This feature requires{" "}
{v.name} version {v.version}
{getBoundText(v.bound)}.
)}
;
};
Cette documentation décrit comment configurer la journalisation avec l'intégration AppSignal for Python.
La journalisation n'est disponible qu'en utilisant le [mode
collector](/python/configuration/collector), qui est une **fonctionnalité
expérimentale**.
## Configurer la journalisation
🔐 N'envoyez pas d'informations personnelles identifiables (PII) à AppSignal. Filtrez les PII (par exemple, noms, e-mails) des journaux et utilisez un identifiant, un hash ou un identifiant pseudonymisé à la place.
Pour les **entités couvertes par la HIPAA**, plus d'informations sur la signature d'un Business Associate Agreement (BAA) sont disponibles dans notre [documentation Business Add-Ons](/support/business-add-ons).
Vous n'avez pas besoin de créer une source de journaux pour envoyer des journaux depuis l'intégration AppSignal for Python. Une source de journaux "application" sera créée automatiquement.
Lors de l'utilisation du [mode collector](/python/configuration/collector), AppSignal instrumente automatiquement le module `logging` intégré de Python via OpenTelemetry, en attachant un handler au logger racine.
### Désactivation de l'instrumentation de journalisation
L'instrumentation du module `logging` de Python peut être désactivée à l'aide de [l'option de configuration `disable_default_instrumentations`](/python/configuration/options#option-disable_default_instrumentations) :
```python Python theme={null}
# __appsignal__.py
appsignal = Appsignal(
# ...
disable_default_instrumentations=["logging"],
)
```
Cela désactive l'instrumentation automatique du module `logging` en attachant un handler au logger racine, ce qui signifie que les journaux envoyés au module `logging` de Python ne seront plus capturés par AppSignal.
Vous pouvez toujours envoyer des journaux directement en utilisant l'API logs d'OpenTelemetry, comme décrit dans la section [Envoi de journaux avec OpenTelemetry](#sending-logs-with-opentelemetry) ci-dessous.
#### Attacher des handlers manuellement
Lorsque l'instrumentation automatique est désactivée, vous pouvez attacher le `LoggingHandler` d'OpenTelemetry à des loggers spécifiques vous-même, plutôt que de compter sur AppSignal pour l'ajouter au logger racine :
```python Python theme={null}
import logging
from opentelemetry.sdk._logs import LoggingHandler
handler = LoggingHandler(level=logging.NOTSET)
logging.getLogger("myapp").addHandler(handler)
```
Cela vous donne le contrôle sur les loggers qui envoient leur sortie à AppSignal.
### Niveau de journal
Le module `logging` de Python est par défaut à `WARNING`, ce qui signifie que les messages `INFO` et `DEBUG` ne sont pas capturés par défaut. Pour capturer les messages de sévérité inférieure, définissez explicitement le niveau du logger racine :
```python Python theme={null}
import logging
logging.root.setLevel(logging.INFO)
```
### Quels journaux sont capturés
AppSignal capture les journaux envoyés au logger racine et à tout logger qui s'y propage. La propagation est contrôlée par l'attribut `propagate` sur chaque logger, qui est par défaut à `True` en Python.
Les loggers avec `propagate=False` n'auront **pas** leurs messages capturés par AppSignal.
## Configuration du framework
### Django
Django configure certains loggers avec `propagate=False` par défaut, ce qui les empêche d'atteindre AppSignal. Remplacez-les dans `settings.py` pour réactiver la propagation :
```python Python theme={null}
# settings.py
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"handlers": {
"console": {"class": "logging.StreamHandler"},
},
"loggers": {
"django.server": {
"handlers": ["console"],
"level": "INFO",
"propagate": True,
},
"myapp": {
"handlers": ["console"],
"level": "INFO",
"propagate": True,
},
},
}
```
Définir `"propagate": True` garantit que les messages du logger atteignent le logger racine, où le handler d'AppSignal est attaché.
#### Attacher des handlers manuellement
Vous pouvez également attacher le `LoggingHandler` directement aux loggers de Django au lieu de compter sur la propagation vers le logger racine :
```python Python theme={null}
# settings.py
import logging
from opentelemetry.sdk._logs import LoggingHandler
LOGGING = {
"version": 1,
"handlers": {
"console": {"class": "logging.StreamHandler"},
"appsignal": {"()": LoggingHandler, "level": logging.NOTSET},
},
"loggers": {
"django.server": {
"handlers": ["console", "appsignal"],
"level": "INFO",
},
"myapp": {
"handlers": ["console", "appsignal"],
"level": "INFO",
},
},
}
```
### Celery
Celery fork des processus worker, donc AppSignal doit être démarré pour chaque fork. Utilisez le signal `worker_process_init` pour réinitialiser AppSignal et configurer la journalisation dans chaque processus worker. Consultez la [page d'instrumentation Celery](/python/instrumentations/celery) pour plus de détails sur l'instrumentation des tâches Celery.
```python Python theme={null}
# tasks.py
import logging
import appsignal
from celery.signals import worker_process_init
@worker_process_init.connect(weak=False)
def init_worker_logging(*args, **kwargs):
appsignal.start()
logging.root.setLevel(logging.INFO)
logging.getLogger("celery").propagate = True
```
## Envoi de journaux avec OpenTelemetry
Vous pouvez également envoyer des journaux directement en utilisant l'API logs d'OpenTelemetry, sans passer par le module `logging` de Python :
```python Python theme={null}
from opentelemetry._logs import get_logger_provider
from opentelemetry.sdk._logs import SeverityNumber
logger_provider = get_logger_provider()
logger = logger_provider.get_logger("my-app")
logger.emit(
logger_provider.get_logger("my-app").create_log_record(
body="Log message line",
severity_number=SeverityNumber.INFO,
)
)
```
## Besoin d'aide ?
Après avoir configuré votre application Python pour envoyer des journaux, les journaux devraient apparaître dans AppSignal. Si vous avez des doutes sur cette étape ou si AppSignal ne reçoit aucun journal, vous pouvez toujours [nous contacter](mailto:support@appsignal.com) pour obtenir de l'aide. Nous vous aiderons à remettre les choses sur la bonne voie !