This feature requires{" "}
{v.name} version {v.version}
{getBoundText(v.bound)}.
)}
;
};
Deze documentatie beschrijft hoe u logging configureert met de AppSignal for Python-integratie.
Logging is alleen beschikbaar bij gebruik van [collector
mode](/python/configuration/collector), wat een **experimentele functie**
is.
## Logging configureren
🔐 Stuur geen Persoonlijk Identificeerbare Informatie (PII) naar AppSignal. Filter PII (bijv. namen, e-mailadressen) uit logs en gebruik in plaats daarvan een ID, hash of gepseudonimiseerde identificator.
Voor **onder HIPAA vallende entiteiten** vindt u meer informatie over het ondertekenen van een Business Associate Agreement (BAA) in onze [documentatie over Business Add-Ons](/support/business-add-ons).
U hoeft geen logbron aan te maken om logs te versturen vanuit de AppSignal for Python-integratie. Er wordt automatisch een "application"-logbron aangemaakt.
Bij gebruik van [collector mode](/python/configuration/collector) instrumenteert AppSignal automatisch de ingebouwde `logging`-module van Python via OpenTelemetry, door een handler aan de root logger te koppelen.
### Logging-instrumentatie uitschakelen
Instrumentatie voor de `logging`-module van Python kan worden uitgeschakeld via [de configuratieoptie `disable_default_instrumentations`](/python/configuration/options#option-disable_default_instrumentations):
```python Python theme={null}
# __appsignal__.py
appsignal = Appsignal(
# ...
disable_default_instrumentations=["logging"],
)
```
Dit schakelt de automatische instrumentatie van de `logging`-module uit door een handler aan de root logger te koppelen, wat betekent dat logs die naar de `logging`-module van Python worden gestuurd niet langer door AppSignal worden opgevangen.
U kunt nog steeds logs direct versturen via de OpenTelemetry logs-API, zoals beschreven in de sectie [Logs versturen met OpenTelemetry](#sending-logs-with-opentelemetry) hieronder.
#### Handlers handmatig koppelen
Wanneer automatische instrumentatie is uitgeschakeld, kunt u de OpenTelemetry `LoggingHandler` zelf aan specifieke loggers koppelen, in plaats van te vertrouwen op AppSignal die deze aan de root logger toevoegt:
```python Python theme={null}
import logging
from opentelemetry.sdk._logs import LoggingHandler
handler = LoggingHandler(level=logging.NOTSET)
logging.getLogger("myapp").addHandler(handler)
```
Hiermee bepaalt u welke loggers hun output naar AppSignal sturen.
### Log-niveau
De `logging`-module van Python heeft standaard `WARNING`, wat betekent dat `INFO`- en `DEBUG`-berichten standaard niet worden vastgelegd. Om berichten met een lagere severity vast te leggen, stelt u het niveau van de root logger expliciet in:
```python Python theme={null}
import logging
logging.root.setLevel(logging.INFO)
```
### Welke logs worden vastgelegd
AppSignal legt logs vast die naar de root logger worden gestuurd en elke logger die ernaar propageert. Propagatie wordt bestuurd door het `propagate`-attribuut op elke logger, dat in Python standaard `True` is.
Loggers met `propagate=False` zullen **niet** hun berichten door AppSignal laten vastleggen.
## Framework-installatie
### Django
Django configureert sommige loggers standaard met `propagate=False`, waardoor ze AppSignal niet bereiken. Overschrijf deze in `settings.py` om propagatie opnieuw in te schakelen:
```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,
},
},
}
```
Het instellen van `"propagate": True` zorgt ervoor dat de berichten van de logger de root logger bereiken, waaraan de handler van AppSignal is gekoppeld.
#### Handlers handmatig koppelen
Als alternatief kunt u de `LoggingHandler` rechtstreeks aan Django's loggers koppelen in plaats van te vertrouwen op propagatie naar de root logger:
```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-werkprocessen, dus AppSignal moet voor elke fork worden gestart. Gebruik het signaal `worker_process_init` om AppSignal opnieuw te initialiseren en logging in elk werkproces te configureren. Zie de [Celery-instrumentatiepagina](/python/instrumentations/celery) voor meer details over het instrumenteren van Celery-taken.
```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
```
## Logs versturen met OpenTelemetry
U kunt ook logs direct versturen via de OpenTelemetry logs-API, zonder de `logging`-module van Python te gebruiken:
```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,
)
)
```
## Hulp nodig?
Nadat u uw Python-applicatie hebt geconfigureerd om logs te versturen, zouden er logs in AppSignal moeten verschijnen. Als u twijfelt over deze stap of AppSignal geen logs ontvangt, kunt u altijd [contact opnemen](mailto:support@appsignal.com) voor hulp. Wij helpen u graag weer op weg!