--- title: "Conas logáil a chumrú agus a úsáid" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/howto/logging/ canonical: https://djangodocs.dev/ga/5.2/howto/logging/ --- # Conas logáil a chumrú agus a úsáid > **See also** > > - \:ref: Tagairt logála Django \` > - \:ref: Forbhreathnú logála Django \` Soláthraíonn Django oibrí:ref: cumraíocht logála réamhshocraithe \\`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. > **Ná bíodh mealladh ort glaonna logála a úsáid i settings.py`.** > > Ciallaíonn an bealach a chuirtear logáil Django mar chuid den fheidhm setup () go bhféadfadh glaonna logála a chuirtear i settings.py oibreoidh mar a bhíothas ag súil leis, toisc nach mbunófar logáil ag an bpointe sin . Chun logáil a iniúchadh, bain úsáid as feidhm amharc mar a mholtar sa sampla thíos. Ar dtús, iompórtáil leabharlann logála Python, agus ansin faigh sampla logger le: py:func: logging.getLogger. Cuir ainm ar fáil don modh getLogger () \`\`chun é a aithint agus na taifid a astaíonn sé. Is é rogha maith ná \`\`\_\_name\_\_\` a úsáid (féach: ref: naming-loggers thíos le haghaidh tuilleadh eolais faoi seo) a sholáthróidh ainm an mhodúil reatha Python mar chonair poncaí: ``` 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: ``` def some_view(request): ... if some_risky_state: logger.warning("Platform is running at risk") ``` Nuair a chuirtear an cód seo i bhfeidhm, seolfar a:py:class: ~logging.logRecord ina bhfuil an teachtaireacht sin chuig an logger. Má tá cumraíocht logála réamhshocraithe Django á úsáid agat, beidh an teachtaireacht le feiceáil sa chonsól. 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\`\, CRITICAL\`. Mar sin, d'fhéadfadh sampla eile a bheith: ``` logger.critical("Payment system is not responding") ``` > **Important** > > Ní bheidh taifid le leibhéal níos ísle ná \`\` RABHADH\`\` le feiceáil sa chonsól de réir réamhshocraithe. Teastaíonn cumraíocht bhreise chun an iompar seo a athrú. ## 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. \Úsáideann an socrú an fhormáid: ref: DictConfig \, 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 \\`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\`: ``` 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", }, }, } ``` Glacann ranganna éagsúla láimhseálaithe roghanna cumraíochta \Le haghaidh tuilleadh faisnéise faoi ranganna láimhseálaithe atá ar fáil, féach an:class: ~django.utils.log.adminEmailHandler a sholáthraíonn Django agus na ranganna éagsúla: py:mod: handler a sholáthraíonn 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ú: ``` 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 \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. Sainmhínítear spás ainmneacha sampla logger ag baint úsáid:py:func: ~logging.getLogger. Mar shampla i views.py\` de `my_app`: ``` 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: ``` 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ú: ``` 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: ``` "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.