djangodocs

Django 6.0
Gaeilge
Documentation contents

Conas logáil a chumrú agus a úsáid

Soláthraíonn Django oibrí:ref: `cumraíocht logála réamhshocraithe <default-logging-configuration>`a leathnaítear go héasca.

Déan glao logála bunúsach

Chun teachtaireacht logála a sheoladh ó laistigh de do chód, cuireann tú glao logála isteach ann.

First, import the Python logging library, and then obtain a logger instance with logging.getLogger(). Provide the getLogger() method with a name to identify it and the records it emits. A good option is to use __name__ (see Úsáid spás ainmneacha logger below for more on this) which will provide the name of the current Python module as a dotted path:

Code
import logging

logger = logging.getLogger(__name__)

Is coinbhinsiún maith é an dearbhú seo a dhéanamh ar leibhéal an mhodúil.

Agus ansin i bhfeidhm, mar shampla i radharc, seol taifead chuig an logger:

Code
def some_view(request):
    ...
    if some_risky_state:
        logger.warning("Platform is running at risk")

When this code is executed, a LogRecord containing that message will be sent to the logger. If you're using Django's default logging configuration, the message will appear in the console.

Tá an leibhéal RABHADH ``a úsáidtear sa sampla thuas ar cheann de roinnt leibhéil déine logála `: `DEBUG, INFO`, RABHADH`, ERROR`<topic-logging-parts-loggers>, CRITICAL`. Mar sin, d'fhéadfadh sampla eile a bheith:

Code
logger.critical("Payment system is not responding")

Saincheapadh cumraíocht logála

Cé go n-oibríonn cumraíocht logála Django as an mbosca, is féidir leat rialú go díreach conas a sheoltar do logaí chuig cinn scríbe éagsúla - chun comhaid, seirbhísí seachtracha, ríomhphost agus mar sin de - a logáil le roinnt cumraíochta breise.

Is féidir leat a chumrú:

  • mapáil logálaí, chun a chinneadh cé na taifid a sheoltar chuig na láimhseálaithe

  • láimhseálaithe, chun a chinneadh cad a dhéanann siad leis na taifid a fhaigheann siad

  • scagairí, chun smacht bhreise a sholáthar ar aistriú taifid, agus fiú taifid a mhodhnú i bhfeidhm

  • formáidithe, chun athró:class: ~Logging.logRecord rudaí a thiontú go sreang nó foirm eile le tomhaltas ag daoine nó córas eile

Tá bealaí éagsúla ann chun logáil a chumrú. I Django, úsáidtear an socrú: setting: LOGGING is coitianta. <default-logging-definition>Úsáideann an socrú an fhormáid: ref: DictConfig <logging-config-dictschema>, agus leathnaíonn sé an:ref: cumraíocht logála réamhshocraithe.

Féach: ref: configuring-loging le haghaidh míniú ar an gcaoi a ndéantar do shocruithe saincheaptha a chumasc le réamhshocruithe Django.

Féach na:mod: Doiciméadú logála Python <python:logging.config>`le haghaidh sonraí faoi bhealaí eile chun logáil a chumrú. Ar mhaithe le simplíocht, ní mheasfaidh an doiciméadú seo cumraíocht ach tríd an socrú ``LOGGING.

Cumraíocht logála bunúsach

Agus logáil á chumrú agat, bíonn sé ciallmhar

Cruthaigh foclóir LOGGING

I do settings.py`:

Code
LOGGING = {
    "version": 1,  # the dictConfig format version
    "disable_existing_loggers": False,  # retain the default loggers
}

Tá sé ciallmhar beagnach i gcónaí an chumraíocht logála réamhshocraithe a choinneáil agus a leathnú trí “disable_existing_loggers” a shocrú go False.

Cumraigh láimhseálaí

Cumraíonn an sampla seo láimhseálaí aonair darb ainm file, a úsáideann Python's:class: ~logging.fileHandler chun logaí de leibhéal DEBUG` agus níos airde chuig an gcomhad ``general.log (ag fréamh an tionscadail) a shábháil:

Python
LOGGING = {
    # ...
    "handlers": {
        "file": {
            "class": "logging.FileHandler",
            "filename": "general.log",
        },
    },
}

Different handler classes take different configuration options. For more information on available handler classes, see the AdminEmailHandler provided by Django and the various handler classes provided by Python.

Is féidir leibhéil logála a shocrú ar na láimhseálaithe freisin (de réir réamhshocraithe, glacann siad le teachtaireachtaí loga de gach leibhéal). Ag baint úsáide as an sampla thuas, ag cur leis:

Python
{
    "class": "logging.FileHandler",
    "filename": "general.log",
    "level": "DEBUG",
}

sainmhíníodh cumraíocht láimhseálaí nach nglacann ach taifid ar leibhéal ``DEBUG` agus níos airde.

Cumraigh mapáil logger

Chun taifid a sheoladh chuig an láimhseálaí seo, cumraigh mapáil logger chun é a úsáid mar shampla:

Python
LOGGING = {
    # ...
    "loggers": {
        "": {
            "level": "DEBUG",
            "handlers": ["file"],
        },
    },
}

Cinneann ainm na mapála cé na taifid logála a phróiseálfaidh sé. Tá an chumraíocht seo ("`) gan ainmne. Ciallaíonn sé sin go ndéanfaidh sé taifid a phróiseáil ó* lógairí uach* (féach:ref: naming-loggers thíos maidir le conas an t-ainm mapála a úsáid chun na logairí a phróiseálfaidh sé taifid a chinneadh).

Cuirfidh sé teachtaireachtaí de leibhéil ``DEBUG` agus níos airde ar aghaidh chuig an láimhseálaí darb ainm ``comhad ``.

Tabhair faoi deara gur féidir le logálaí teachtaireachtaí a chur ar aghaidh chuig láimhseálaithe iolracha, mar sin tá an gaol idir lógairí agus láimhseálaithe go leor.

Má fhorghníomhaíonn tú:

Code
logger.debug("Attempting to connect to API")

i do chód, gheobhaidh tú an teachtaireacht sin sa chomhad general.log i bhfréamh an tionscadail.

Cumraigh formáiditheoir

<logging.LogRecord>De réir réamhshocraithe, tá an chuid teachtaireachta de gach ceann: class: log record `sa aschur logála deiridh. Úsáid formáiditheoir más mian leat sonraí breise a chur san áireamh. Céad ainm agus sainmhínigh do chuid formáidithe - sainmhíníonn an sampla seo formáidithe darb ainm ``verbose` agus simpl:

Python
LOGGING = {
    # ...
    "formatters": {
        "verbose": {
            "format": "{name} {levelname} {asctime} {module} {process:d} {thread:d} {message}",
            "style": "{",
        },
        "simple": {
            "format": "{levelname} {message}",
            "style": "{",
        },
    },
}

Ligeann an eochairfhocal style duit { a shonrú for:meth: str.format nó $ formáidiú: class: `String.template; is é $` an réamhshocraithe.

Féach: ref: logrecord-atritributes do thréithe: class: ~logging.logrecord is féidir leat a chur san áireamh.

Chun formáiditheoir a chur i bhfeidhm ar láimhseálaí, cuir iontráil ``formáiditheoir ``le foclóir an láimhseálaí ag tagairt don fhormáiditheoir de réir ainm, mar shampla:

Python
"handlers": {
    "file": {
        "class": "logging.FileHandler",
        "filename": "general.log",
        "formatter": "verbose",
    },
}

Úsáid spás ainmneacha logger

Gabhann an chumraíocht logála gan ainm ```logaí ó aon fheidhmchlár Python. Ní ghlacfaidh cumraíocht logála ainmnithe logaí ach ó logálaithe le hainmneacha meaitseála.

The namespace of a logger instance is defined using getLogger(). For example in views.py of my_app:

Code
logger = logging.getLogger(__name__)

cruthóidh sé logálaí sa spás ainmneacha my_app.views. Ligeann __name__ duit teachtaireachtaí logála a eagrú de réir a dtionscnaimh laistigh d'iarratais do thionscadail go huathoibríoch. Cinntíonn sé freisin nach mbeidh imbhuailtí ainmneacha agat.

Gabhfaidh mapáil logaire darb ainm my_app.views taifid ón logger seo:

Python
LOGGING = {
    # ...
    "loggers": {
        "my_app.views": {...},
    },
}

Beidh mapáil logálaí darb ainm my_app` níos ceadaithe, ag gabháil taifid ó loggers áit ar bith laistigh den spás ainmneacha my_app (lena n-áirítear my_app.views, my_app.utils`, agus mar sin de):

Python
LOGGING = {
    # ...
    "loggers": {
        "my_app": {...},
    },
}

Is féidir leat spás ainmneacha logger a shainiú go sainráite freisin:

Code
logger = logging.getLogger("project.payment")

agus mharpálacha logaire a chur ar bun dá réir.

Ag baint úsáide as ordlathais logger agus iomadú

Is é ainmniú logger* ordlathach*. Is é my_app` tuismitheoir my_app.views, arb é tuismitheoir my_app.views.private. Mura sonraítear a mhalairt, iomadóidh mapáil logger na taifid a phróiseálann siad dá dtuismitheoirí - déanfar taifead ó logálaí sa spás ainmneacha my_app.views.private a láimhseáil le mapáil do my_app agus my_app.views` araon.

Chun an t-iompar seo a bhainistiú, socraigh an eochair iomadaithe ar na mapálacha a shainmhíníonn tú:

Code
LOGGING = {
    # ...
    "loggers": {
        "my_app": {
            # ...
        },
        "my_app.views": {
            # ...
        },
        "my_app.views.private": {
            # ...
            "propagate": False,
        },
    },
}

Tá iomada réamhshocraithe go True. Sa sampla seo, ní láimhseálfaidh an tuismitheoir na logaí ó my_app.views.private`, ach déanfaidh logaí ó my_app.views`.

Cumraigh logáil sofhreagrach

Tá logáil is úsáideach nuair a bhíonn an oiread faisnéise agus is féidir ann, ach ní faisnéis nach dteastaíonn uait - agus braitheann an méid a theastaíonn uait ar an méid atá á dhéanamh agat. Nuair a bhíonn tú ag dífhabhtú, teastaíonn leibhéal faisnéise uait a bheadh iomarcach agus neamhchabhrach dá mbeadh ort déileáil leis i dtáirgeadh.

Is féidir leat logáil a chumrú chun an leibhéal sonraí a theastaíonn uait a sholáthar duit, nuair is gá duit é. Seachas an chumraíocht a athrú de láimh chun é seo a bhaint amach, is é bealach níos fearr ná cumraíocht a chur i bhfeidhm go huathoibríoch de réir an chomhshaoil.

Mar shampla, d'fhéadfá athróg comhshaoil DJANGO_LOG_LEVEL a shocrú go cuí i do thimpeallachtaí forbartha agus stáitse, agus úsáid a bhaint as i mapáil logaire mar sin:

Code
"level": os.getenv("DJANGO_LOG_LEVEL", "WARNING")

- ionas nach gcuirfidh an chumraíocht seo ach taifid déine `RABHADH `RABHADH ``agus os cionn chuig a láimhseálaí mura sonraíonn an timpeallacht leibhéal logála níos ísle.

Is féidir roghanna eile sa chumraíocht (mar shampla an rogha láimhseálaithe leibhéil ``nó `formáiditheoir) a bhainistiú ar an gcaoi chéanna.

View as Markdown Edit this page on GitHub Official version