Automatisch volgen

logfire.install_auto_tracing Alle functieaanroepen in de opgegeven module worden bijgehouden.

Dit wordt bereikt door de manier waarop deze modules worden geïmporteerd te wijzigen, dus de functie moet worden aangeroepen voordat de te traceren module wordt geïmporteerd.

Stel dat al uw code zich in het 应用程序-pakket bevindt, zoals app.main,app.server,app.db, enz. U kunt een ander bestand maken buiten het 应用程序-pakket in plaats van de applicatie te starten met python app/main.py, bijvoorbeeld:

main.py

import logfire

logfire.configure()
logfire.install_auto_tracing(modules=['app'])

from app.main import main

main()

Filter modules om te volgen

De modules parameter kan een lijst van module namen zijn. Eventuele submodules binnen een bepaalde module zullen ook worden bijgehouden, zoals app.main en app.server. Andere modules waarvan de namen beginnen met hetzelfde voorvoegsel zullen niet worden bijgehouden, zoals 苹果.

Als een van de strings in de lijst geen geldige modulenaam is, wordt deze behandeld als een reguliere expressie, dus bijvoorbeeld modules=['app.*'] volgt 苹果 naastapp.main enzovoort.

Voor meer controle kan het modules-argument een functie zijn die True retourneert voor de module die moet worden getraceerd. Deze functie gebruikt het [AutoTraceModule ][logfire 调用。AutoTraceModule]-object, dat name- en filename-eigenschappen heeft. Dit zou bijvoorbeeld alle modules in een typische Python-installatie moeten volgen die geen deel uitmaken van de standaardbibliotheek of pakketten van derden.

import pathlib

import logfire

PYTHON_LIB_ROOT = str(pathlib.Path(pathlib.__file__).parent)


def should_trace(module: logfire.AutoTraceModule) -> bool:
    return not module.filename.startswith(PYTHON_LIB_ROOT)


logfire.install_auto_tracing(should_trace)

Functies uitsluiten van tracing

Nadat u de modules hebt geselecteerd die u wilt volgen, wilt u mogelijk geen van die modules volgen_elke_Functie. Om een functie uit te sluiten van automatische tracering, voegt u deze no_auto_trace Decorator:

import logfire

@logfire.no_auto_trace
def my_function():
    # 嵌套函数也将被排除在外
    def inner_function():
        ...

    return other_function()


    # 此功能*不*从自动跟踪中排除。
    # 即使从上面排除的 'my_function' 调用，它仍然会被追踪。
def other_function():
    ...


# 修饰类的所有方法也将被排除在外
@no_auto_trace
class MyClass:
    def my_method(self):
        ...

Decorator gedetecteerd bij import. Alleen @no_auto_trace of @logfire.no_auto_trace worden ondersteund. Het hernoemen / aliassen van een functie of module zal niet werken. Evenmin zal het indirect worden aangeroepen via een andere functie.

Deze decorateur retourneert alleen ongewijzigde parameters, dus de runtime-overhead is nul.

Alleen trackfuncties die de kortste duur overschrijden

Een gemakkelijkere manier om functies van tracering uit te sluiten, is door de parameter [min_duration ][logfire.Logfire.install_auto_tracing(min_duration)] in te stellen, bijvoorbeeld:

# Only trace functions that take longer than 0.1 seconds
logfire.install_auto_tracing(modules=['app'], min_duration=0.1)

Dit betekent dat u automatisch waarneembaarheid van zwaardere delen van uw toepassing kunt krijgen zonder veel overhead of gegevens. Houd er rekening mee dat er een paar kanttekeningen zijn:

• Functies worden pas gevolgd na meer dan min_duration-tijden. Dit betekent:

  • Als het sneller werkt dan de eerste paar min_duration-oproepen, heb je geen toegang tot gegevens over die eerste oproepen.

  • Als je voor het eerst meer dan min_duration draait, krijg je ook geen gegevens over dat gesprek.

• Als een functie meer dan min_duration draait, wordt deze elke keer dat de functie wordt aangeroepen bijgehouden, ongeacht hoe lang het duurt.

• Het meten van de duur van functieaanroepen voegt nog steeds een kleine hoeveelheid overhead toe. Voor kleine functies die zeer vaak worden aangeroepen, is het nog steeds het beste om de @no_auto_trace-decorateur te gebruiken om overhead te vermijden. Automatische tracering met min_duration werkt nog steeds voor andere onversierde functies.

---

本文总阅读量次